Date format: Difference between revisions
No edit summary |
→Nu: add |
||
(45 intermediate revisions by 24 users not shown) | |||
Line 9: | Line 9: | ||
=={{header|11l}}== |
=={{header|11l}}== |
||
< |
<syntaxhighlight lang="11l">print(Time().format(‘YYYY-MM-DD’)) |
||
print(Time().strftime(‘%A, %B %e, %Y’))</ |
print(Time().strftime(‘%A, %B %e, %Y’))</syntaxhighlight> |
||
=={{header|68000 Assembly}}== |
|||
{{works with|NEOGEO MVS}} |
|||
This code only works on the arcade system, not the home consoles, because only the arcade system has a built-in system clock. which can be read using <code>JSR $C0045C</code>. MAME uses your computer's date and time as the source for this data. The code below runs in-line and uses a few macros and labels, but they are mostly self-explanatory. The code required to set up the palettes and print characters to the screen has been omitted for brevity, but is fully implemented. |
|||
<syntaxhighlight lang="68000devpac"> JSR SYS_READ_CALENDAR ;outputs calendar date to BIOS RAM |
|||
MOVE.B #'2',D0 ;a character in single or double quotes refers to its ascii equivalent. |
|||
JSR PrintChar |
|||
MOVE.B #'0',D0 |
|||
JSR PrintChar |
|||
LEA BIOS_YEAR,A1 |
|||
MOVE.B (A1)+,D0 ;stores last 2 digits of year into D0, in binary coded decimal |
|||
JSR UnpackNibbles8 ;separate the digits into high and low nibbles: D0 = 00020001 |
|||
ADD.L #$00300030,D0 ;convert both numerals to their ascii equivalents. |
|||
SWAP D0 ;print the "2" first |
|||
JSR PrintChar |
|||
SWAP D0 ;then the "1" |
|||
JSR PrintChar |
|||
MOVE.B #'-',D0 |
|||
JSR PrintChar |
|||
MOVE.B (A1)+,D0 ;get the month |
|||
JSR UnpackNibbles8 |
|||
ADD.L #$00300030,D0 |
|||
SWAP D0 |
|||
JSR PrintChar |
|||
SWAP D0 |
|||
JSR PrintChar |
|||
MOVE.B #'-',D0 |
|||
JSR PrintChar |
|||
MOVE.B (A1)+,D0 ;get the day |
|||
JSR UnpackNibbles8 |
|||
ADD.L #$00300030,D0 |
|||
SWAP D0 |
|||
JSR PrintChar |
|||
SWAP D0 |
|||
JSR PrintChar |
|||
;now the date is printed. |
|||
;Now do it again only written out: |
|||
jsr NewLine |
|||
CLR.L D0 ;reset D0 |
|||
MOVE.B (A1),D0 ;A1 happens to point to the weekday |
|||
LSL.W #2,D0 ;we are indexing into a table of longs |
|||
LEA Days_Lookup,A2 |
|||
LEA (A2,D0),A2 |
|||
MOVEA.L (A2),A3 ;dereference the pointer into A3, which the PrintString routine takes as an argument. |
|||
JSR PrintString |
|||
CLR.L D0 |
|||
LEA BIOS_MONTH,A1 ;GET THE MONTH |
|||
MOVE.B (A1)+,D0 |
|||
LSL.W #2,D0 |
|||
LEA Months_Lookup,A2 |
|||
LEA (A2,D0),A2 |
|||
MOVEA.L (A2),A3 |
|||
JSR PrintString |
|||
MOVE.B (A1),D0 ;GET THE DAY |
|||
JSR UnpackNibbles8 |
|||
ADD.L #$00300030,D0 |
|||
SWAP D0 |
|||
JSR PrintChar |
|||
SWAP D0 |
|||
JSR PrintChar |
|||
MOVE.B #',',D0 |
|||
JSR PrintChar |
|||
MOVE.B #' ',D0 |
|||
JSR PrintChar |
|||
MOVE.B #'2',D0 |
|||
JSR PrintChar |
|||
MOVE.B #'0',D0 |
|||
JSR PrintChar |
|||
LEA BIOS_YEAR,A1 |
|||
MOVE.B (A1)+,D0 ;stores last 2 digits of year into D0, in binary coded decimal |
|||
JSR UnpackNibbles8 ;separate the digits into high and low nibbles: D0 = 00020001 |
|||
ADD.L #$00300030,D0 ;convert both numerals to their ascii equivalents. |
|||
SWAP D0 ;print the "2" first |
|||
JSR PrintChar |
|||
SWAP D0 ;then the "1" |
|||
JSR PrintChar |
|||
forever: |
|||
bra forever ;trap the program counter |
|||
UnpackNibbles8: |
|||
; INPUT: D0 = THE VALUE YOU WISH TO UNPACK. |
|||
; HIGH NIBBLE IN HIGH WORD OF D0, LOW NIBBLE IN LOW WORD. SWAP D0 TO GET THE OTHER HALF. |
|||
pushWord D1 |
|||
CLR.W D1 |
|||
MOVE.B D0,D1 |
|||
CLR.L D0 |
|||
MOVE.B D1,D0 ;now D0 = D1 = $000000II, where I = input |
|||
AND.B #$F0,D0 ;chop off bottom nibble |
|||
LSR.B #4,D0 ;downshift top nibble into bottom nibble of the word |
|||
SWAP D0 ;store in high word |
|||
AND.B #$0F,D1 ;chop off bottom nibble |
|||
MOVE.B D1,D0 ;store in low word |
|||
popWord D1 |
|||
rts</syntaxhighlight> |
|||
Output can be seen [https://ibb.co/52Ks0yf here,] but is also reproduced below: |
|||
<pre> |
|||
2021-09-19 |
|||
Sunday, September 19, 2021 |
|||
</pre> |
|||
=={{header|8th}}== |
=={{header|8th}}== |
||
< |
<syntaxhighlight lang="forth"> |
||
d:new |
d:new |
||
"%Y-%M-%D" over d:format . cr |
"%Y-%M-%D" over d:format . cr |
||
"%W, %N %D, %Y" over d:format . cr |
"%W, %N %D, %Y" over d:format . cr |
||
bye |
bye |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|AArch64 Assembly}}== |
=={{header|AArch64 Assembly}}== |
||
{{works with|as|Raspberry Pi 3B version Buster 64 bits}} |
{{works with|as|Raspberry Pi 3B version Buster 64 bits}} |
||
<syntaxhighlight lang="aarch64 assembly"> |
|||
<lang AArch64 Assembly> |
|||
/* ARM assembly AARCH64 Raspberry PI 3B */ |
/* ARM assembly AARCH64 Raspberry PI 3B */ |
||
/* program dateFormat64.s */ |
/* program dateFormat64.s */ |
||
Line 342: | Line 463: | ||
/* for this file see task include a file in language AArch64 assembly */ |
/* for this file see task include a file in language AArch64 assembly */ |
||
.include "../includeARM64.inc" |
.include "../includeARM64.inc" |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|ABAP}}== |
=={{header|ABAP}}== |
||
<syntaxhighlight lang="abap"> |
|||
<lang ABAP> |
|||
report zdate. |
report zdate. |
||
data: lv_month type string, |
data: lv_month type string, |
||
Line 366: | Line 487: | ||
concatenate sy-datum(4) '-' sy-datum+4(2) '-' sy-datum+6(2) into lv_date. |
concatenate sy-datum(4) '-' sy-datum+4(2) '-' sy-datum+6(2) into lv_date. |
||
write / lv_date. |
write / lv_date. |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Action!}}== |
|||
<syntaxhighlight lang="action!">DEFINE PTR="CARD" |
|||
TYPE Date=[ |
|||
INT year |
|||
BYTE month |
|||
BYTE day] |
|||
PTR ARRAY DayOfWeeks(7) |
|||
PTR ARRAY Months(12) |
|||
PROC Init() |
|||
DayOfWeeks(0)="Sunday" DayOfWeeks(1)="Monday" |
|||
DayOfWeeks(2)="Tuesday" DayOfWeeks(3)="Wednesday" |
|||
DayOfWeeks(4)="Thursday" DayOfWeeks(5)="Friday" |
|||
DayOfWeeks(6)="Saturday" |
|||
Months(0)="January" Months(1)="February" |
|||
Months(2)="March" Months(3)="April" |
|||
Months(4)="May" Months(5)="June" |
|||
Months(6)="July" Months(7)="August" |
|||
Months(8)="September" Months(9)="October" |
|||
Months(10)="November" Months(11)="December" |
|||
RETURN |
|||
;https://en.wikipedia.org/wiki/Determination_of_the_day_of_the_week#Sakamoto.27s_methods |
|||
BYTE FUNC DayOfWeek(Date POINTER d) ;1<=m<=12, y>1752 |
|||
BYTE ARRAY t=[0 3 2 5 0 3 5 1 4 6 2 4] |
|||
BYTE res |
|||
INT y |
|||
y=d.year |
|||
IF d.month<3 THEN |
|||
y==-1 |
|||
FI |
|||
res=(y+y/4-y/100+y/400+t(d.month-1)+d.day) MOD 7 |
|||
RETURN (res) |
|||
PROC PrintB2(BYTE x) |
|||
IF x<10 THEN |
|||
Put('0) |
|||
FI |
|||
PrintB(x) |
|||
RETURN |
|||
PROC PrintDateShort(Date POINTER d) |
|||
PrintI(d.year) Put('-) |
|||
PrintB2(d.month) Put('-) |
|||
PrintB2(d.day) |
|||
RETURN |
|||
PROC PrintDateLong(Date POINTER d) |
|||
BYTE wd |
|||
wd=DayOfWeek(d) |
|||
Print(DayOfWeeks(wd)) Print(", ") |
|||
Print(Months(d.month-1)) Put(' ) |
|||
PrintB(d.day) Print(", ") |
|||
PrintI(d.year) |
|||
RETURN |
|||
PROC Main() |
|||
Date d |
|||
Init() |
|||
;There is no function to get the current date |
|||
;on Atari 8-bit computer |
|||
d.year=2021 d.month=9 d.day=1 |
|||
PrintDateShort(d) PutE() |
|||
PrintDateLong(d) PutE() |
|||
RETURN</syntaxhighlight> |
|||
{{out}} |
|||
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Date_format.png Screenshot from Atari 8-bit computer] |
|||
<pre> |
|||
2021-09-01 |
|||
Wednesday, September 1, 2021 |
|||
</pre> |
|||
=={{header|Ada}}== |
=={{header|Ada}}== |
||
< |
<syntaxhighlight lang="ada">with Ada.Calendar; use Ada.Calendar; |
||
with Ada.Calendar.Formatting; use Ada.Calendar.Formatting; |
with Ada.Calendar.Formatting; use Ada.Calendar.Formatting; |
||
with Ada.Text_IO; use Ada.Text_IO; |
with Ada.Text_IO; use Ada.Text_IO; |
||
Line 412: | Line 612: | ||
& Year_Number'Image (Ada.Calendar.Year (Today)) |
& Year_Number'Image (Ada.Calendar.Year (Today)) |
||
); |
); |
||
end Date_Format;</ |
end Date_Format;</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 425: | Line 625: | ||
Note: the '''format''' can be used for both printing ''and'' reading date data. |
Note: the '''format''' can be used for both printing ''and'' reading date data. |
||
< |
<syntaxhighlight lang="algol68"># define the layout of the date/time as provided by the call to local time # |
||
STRUCT ( INT sec, min, hour, mday, mon, year, wday, yday, isdst) tm = (6,5,4,3,2,1,7,~,8); |
STRUCT ( INT sec, min, hour, mday, mon, year, wday, yday, isdst) tm = (6,5,4,3,2,1,7,~,8); |
||
Line 447: | Line 647: | ||
printf((unix time repr, now[wday OF tm], now[mon OF tm], now[mday OF tm], |
printf((unix time repr, now[wday OF tm], now[mon OF tm], now[mday OF tm], |
||
now[hour OF tm:sec OF tm], now[isdst OF tm]+1, now[year OF tm], $l$))</ |
now[hour OF tm:sec OF tm], now[isdst OF tm]+1, now[year OF tm], $l$))</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 456: | Line 656: | ||
=={{header|Apex}}== |
=={{header|Apex}}== |
||
< |
<syntaxhighlight lang="java"> |
||
Datetime dtNow = datetime.now(); |
Datetime dtNow = datetime.now(); |
||
String strDt1 = dtNow.format('yyyy-MM-dd'); |
String strDt1 = dtNow.format('yyyy-MM-dd'); |
||
Line 462: | Line 662: | ||
system.debug(strDt1); // "2007-11-10" |
system.debug(strDt1); // "2007-11-10" |
||
system.debug(strDt2); //"Sunday, November 10, 2007" |
system.debug(strDt2); //"Sunday, November 10, 2007" |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
Line 477: | Line 677: | ||
Whether or not they happen to work, to insist on posting code containing things which have never been part of the language without noting them as hacks, when they're entirely unnecessary, and deleting legitimate and effective code to make way for them, is seriously to misinform readers. |
Whether or not they happen to work, to insist on posting code containing things which have never been part of the language without noting them as hacks, when they're entirely unnecessary, and deleting legitimate and effective code to make way for them, is seriously to misinform readers. |
||
< |
<syntaxhighlight lang="applescript">set {year:y, month:m, day:d, weekday:w} to (current date) |
||
tell (y * 10000 + m * 100 + d) as text to set shortFormat to text 1 thru 4 & "-" & text 5 thru 6 & "-" & text 7 thru 8 |
tell (y * 10000 + m * 100 + d) as text to set shortFormat to text 1 thru 4 & "-" & text 5 thru 6 & "-" & text 7 thru 8 |
||
set longFormat to (w as text) & (", " & m) & (space & d) & (", " & y) |
set longFormat to (w as text) & (", " & m) & (space & d) & (", " & y) |
||
return (shortFormat & linefeed & longFormat)</ |
return (shortFormat & linefeed & longFormat)</syntaxhighlight> |
||
{{output}} |
{{output}} |
||
< |
<syntaxhighlight lang="applescript">"2020-10-28 |
||
Wednesday, October 28, 2020"</ |
Wednesday, October 28, 2020"</syntaxhighlight> |
||
===Hack alternative=== |
===Hack alternative=== |
||
Line 502: | Line 702: | ||
< |
<syntaxhighlight lang="applescript">tell (the current date) |
||
set shortdate to text 1 thru 10 of (it as «class isot» as string) |
set shortdate to text 1 thru 10 of (it as «class isot» as string) |
||
set longdate to the contents of [its weekday, ", ", ¬ |
set longdate to the contents of [its weekday, ", ", ¬ |
||
Line 509: | Line 709: | ||
log the shortdate |
log the shortdate |
||
log the longdate</ |
log the longdate</syntaxhighlight> |
||
{{output}} |
{{output}} |
||
Line 518: | Line 718: | ||
Or, emphasising productivity and functional composition: |
Or, emphasising productivity and functional composition: |
||
< |
<syntaxhighlight lang="applescript">-- iso8601Short :: Date -> String |
||
on iso8601Short(dte) |
on iso8601Short(dte) |
||
text 1 thru 10 of iso8601Local(dte) |
text 1 thru 10 of iso8601Local(dte) |
||
Line 588: | Line 788: | ||
set my text item delimiters to dlm |
set my text item delimiters to dlm |
||
s |
s |
||
end unlines</ |
end unlines</syntaxhighlight> |
||
{{Out}} |
{{Out}} |
||
<pre>2020-09-11 |
<pre>2020-09-11 |
||
Line 595: | Line 795: | ||
=={{header|ARM Assembly}}== |
=={{header|ARM Assembly}}== |
||
{{works with|as|Raspberry Pi}} |
{{works with|as|Raspberry Pi}} |
||
<syntaxhighlight lang="arm assembly"> |
|||
<lang ARM Assembly> |
|||
/* ARM assembly Raspberry PI */ |
/* ARM assembly Raspberry PI */ |
||
/* program dateFormat.s */ |
/* program dateFormat.s */ |
||
Line 943: | Line 1,143: | ||
/***************************************************/ |
/***************************************************/ |
||
.include "../affichage.inc" |
.include "../affichage.inc" |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{Output}} |
{{Output}} |
||
<pre> |
<pre> |
||
Line 958: | Line 1,158: | ||
=={{header|Arturo}}== |
=={{header|Arturo}}== |
||
< |
<syntaxhighlight lang="rebol">currentTime: now |
||
print to :string.format: "YYYY-MM-dd" currentTime |
print to :string.format: "YYYY-MM-dd" currentTime |
||
print to :string.format: "dddd, MMMM dd, YYYY" currentTime</ |
print to :string.format: "dddd, MMMM dd, YYYY" currentTime</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 969: | Line 1,169: | ||
=={{header|AutoHotkey}}== |
=={{header|AutoHotkey}}== |
||
< |
<syntaxhighlight lang="autohotkey">FormatTime, Date1, , yyyy-MM-dd ; "2007-11-10" |
||
FormatTime, Date2, , LongDate ; "Sunday, November 10, 2007" |
FormatTime, Date2, , LongDate ; "Sunday, November 10, 2007" |
||
MsgBox %Date1% `n %Date2%</ |
MsgBox %Date1% `n %Date2%</syntaxhighlight> |
||
=={{header|AutoIt}}== |
=={{header|AutoIt}}== |
||
This solution uses the locale settings for names of days and months. |
This solution uses the locale settings for names of days and months. |
||
<syntaxhighlight lang="autoit"> |
|||
<lang AutoIt> |
|||
#include <Date.au3> |
#include <Date.au3> |
||
Line 1,007: | Line 1,207: | ||
Return $ret[3] |
Return $ret[3] |
||
EndFunc |
EndFunc |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 1,017: | Line 1,217: | ||
=={{header|AWK}}== |
=={{header|AWK}}== |
||
{{works with|Gawk}} |
{{works with|Gawk}} |
||
< |
<syntaxhighlight lang="awk">$ awk 'BEGIN{t=systime();print strftime("%Y-%m-%d",t)"\n"strftime("%A, %B %d, %Y",t)}' |
||
2009-05-15 |
2009-05-15 |
||
Friday, May 15, 2009</ |
Friday, May 15, 2009</syntaxhighlight> |
||
=={{header|BaCon}}== |
=={{header|BaCon}}== |
||
< |
<syntaxhighlight lang="freebasic">' Date format |
||
n = NOW |
n = NOW |
||
PRINT YEAR(n), MONTH(n), DAY(n) FORMAT "%ld-%02ld-%02ld\n" |
PRINT YEAR(n), MONTH(n), DAY(n) FORMAT "%ld-%02ld-%02ld\n" |
||
PRINT WEEKDAY$(n), MONTH$(n), DAY(n), YEAR(n) FORMAT "%s, %s %02ld, %ld\n"</ |
PRINT WEEKDAY$(n), MONTH$(n), DAY(n), YEAR(n) FORMAT "%s, %s %02ld, %ld\n"</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 1,034: | Line 1,234: | ||
=={{header|BASIC}}== |
=={{header|BASIC}}== |
||
{{works with|FreeBASIC}} |
{{works with|FreeBASIC}} |
||
< |
<syntaxhighlight lang="freebasic">#include "vbcompat.bi" |
||
DIM today As Double = Now() |
DIM today As Double = Now() |
||
PRINT Format(today, "yyyy-mm-dd") |
PRINT Format(today, "yyyy-mm-dd") |
||
PRINT Format(today, "dddd, mmmm d, yyyy")</ |
PRINT Format(today, "dddd, mmmm d, yyyy")</syntaxhighlight> |
||
=={{header|Batch File}}== |
=={{header|Batch File}}== |
||
< |
<syntaxhighlight lang="dos"> |
||
@echo off |
@echo off |
||
setlocal enabledelayedexpansion |
setlocal enabledelayedexpansion |
||
Line 1,078: | Line 1,278: | ||
echo %fulldayname%, %monthname% %day%, %year% |
echo %fulldayname%, %monthname% %day%, %year% |
||
pause>nul |
pause>nul |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 1,086: | Line 1,286: | ||
=={{header|BBC BASIC}}== |
=={{header|BBC BASIC}}== |
||
< |
<syntaxhighlight lang="bbcbasic"> daysow$ = "Sunday Monday Tuesday Wednesday Thursday Friday Saturday" |
||
months$ = "January February March April May June " + \ |
months$ = "January February March April May June " + \ |
||
\ "July August September October November December" |
\ "July August September October November December" |
||
Line 1,103: | Line 1,303: | ||
DEF FNrtrim(A$) |
DEF FNrtrim(A$) |
||
WHILE RIGHT$(A$) = " " A$ = LEFT$(A$) : ENDWHILE |
WHILE RIGHT$(A$) = " " A$ = LEFT$(A$) : ENDWHILE |
||
= A$</ |
= A$</syntaxhighlight> |
||
=={{header|Beads}}== |
=={{header|Beads}}== |
||
Line 1,133: | Line 1,333: | ||
// [iso time] = [hour]:[minute]:[second], e.g. 18:06:05 |
// [iso time] = [hour]:[minute]:[second], e.g. 18:06:05 |
||
</pre> |
</pre> |
||
< |
<syntaxhighlight lang="beads">beads 1 program 'Date format' |
||
calc main_init |
calc main_init |
||
log time_to_str('[iso date]') |
log time_to_str('[iso date]') |
||
log time_to_str('[sunday], [january] [day2], [year]')</ |
log time_to_str('[sunday], [january] [day2], [year]')</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 1,146: | Line 1,346: | ||
=={{header|C}}== |
=={{header|C}}== |
||
< |
<syntaxhighlight lang="c">#include <stdlib.h> |
||
#include <stdio.h> |
#include <stdio.h> |
||
#include <time.h> |
#include <time.h> |
||
Line 1,168: | Line 1,368: | ||
(void) printf("%s\n", buf); |
(void) printf("%s\n", buf); |
||
return EXIT_SUCCESS; |
return EXIT_SUCCESS; |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 1,176: | Line 1,376: | ||
=={{header|C sharp|C#}}== |
=={{header|C sharp|C#}}== |
||
< |
<syntaxhighlight lang="csharp">using System; |
||
namespace RosettaCode.DateFormat |
namespace RosettaCode.DateFormat |
||
Line 1,189: | Line 1,389: | ||
} |
} |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
=={{header|C++}}== |
=={{header|C++}}== |
||
< |
<syntaxhighlight lang="cpp">// Display the current date in the formats of "2007-11-10" |
||
// and "Sunday, November 10, 2007". |
// and "Sunday, November 10, 2007". |
||
Line 1,255: | Line 1,455: | ||
std::cout << d.getTextDate() << std::endl; |
std::cout << d.getTextDate() << std::endl; |
||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 1,263: | Line 1,463: | ||
=={{header|Clojure}}== |
=={{header|Clojure}}== |
||
< |
<syntaxhighlight lang="lisp">(let [now (.getTime (java.util.Calendar/getInstance)) |
||
f1 (java.text.SimpleDateFormat. "yyyy-MM-dd") |
f1 (java.text.SimpleDateFormat. "yyyy-MM-dd") |
||
f2 (java.text.SimpleDateFormat. "EEEE, MMMM dd, yyyy")] |
f2 (java.text.SimpleDateFormat. "EEEE, MMMM dd, yyyy")] |
||
(println (.format f1 now)) |
(println (.format f1 now)) |
||
(println (.format f2 now)))</ |
(println (.format f2 now)))</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 1,275: | Line 1,475: | ||
=={{header|COBOL}}== |
=={{header|COBOL}}== |
||
{{works with|OpenCOBOL}} |
{{works with|OpenCOBOL}} |
||
< |
<syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION. |
||
PROGRAM-ID. Date-Format. |
PROGRAM-ID. Date-Format. |
||
Line 1,338: | Line 1,538: | ||
GOBACK |
GOBACK |
||
.</ |
.</syntaxhighlight> |
||
=={{header|CoffeeScript}}== |
=={{header|CoffeeScript}}== |
||
=== ECMAScript ≥ 5.1 === |
=== ECMAScript ≥ 5.1 === |
||
Is supported by at least: Chrome 24, Firefox/Gecko 29, IE 11, Opera 15, and Node.js (at least as of 2015). |
Is supported by at least: Chrome 24, Firefox/Gecko 29, IE 11, Opera 15, and Node.js (at least as of 2015). |
||
< |
<syntaxhighlight lang="coffeescript"> |
||
date = new Date |
date = new Date |
||
Line 1,357: | Line 1,557: | ||
day: 'numeric' |
day: 'numeric' |
||
year: 'numeric' |
year: 'numeric' |
||
</syntaxhighlight> |
|||
</lang> |
|||
=== Portable version === |
=== Portable version === |
||
< |
<syntaxhighlight lang="coffeescript"> |
||
# JS does not have extensive formatting support out of the box. This code shows |
# JS does not have extensive formatting support out of the box. This code shows |
||
# how you could create a date formatter object. |
# how you could create a date formatter object. |
||
Line 1,387: | Line 1,587: | ||
console.log formatter.brief(date) |
console.log formatter.brief(date) |
||
console.log formatter.verbose(date) |
console.log formatter.verbose(date) |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 1,396: | Line 1,596: | ||
=={{header|ColdFusion}}== |
=={{header|ColdFusion}}== |
||
< |
<syntaxhighlight lang="cfm"><cfoutput> |
||
#dateFormat(Now(), "YYYY-MM-DD")#<br /> |
#dateFormat(Now(), "YYYY-MM-DD")#<br /> |
||
#dateFormat(Now(), "DDDD, MMMM DD, YYYY")# |
#dateFormat(Now(), "DDDD, MMMM DD, YYYY")# |
||
</cfoutput></ |
</cfoutput></syntaxhighlight> |
||
=={{header|Common Lisp}}== |
=={{header|Common Lisp}}== |
||
< |
<syntaxhighlight lang="lisp">(defconstant *day-names* |
||
#("Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday" "Sunday")) |
#("Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday" "Sunday")) |
||
(defconstant *month-names* |
(defconstant *month-names* |
||
Line 1,411: | Line 1,611: | ||
(format t "~4d-~2,'0d-~2,'0d~%" year month date) |
(format t "~4d-~2,'0d-~2,'0d~%" year month date) |
||
(format t "~a, ~a ~d, ~4d~%" |
(format t "~a, ~a ~d, ~4d~%" |
||
(aref *day-names* day) (aref *month-names* month) date year))</ |
(aref *day-names* day) (aref *month-names* month) date year))</syntaxhighlight> |
||
With the local-time library: |
With the local-time library: |
||
< |
<syntaxhighlight lang="lisp"> |
||
(local-time:format-timestring nil (local-time:now) :format '(:year "-" (:month 2) "-" (:day 2))) |
(local-time:format-timestring nil (local-time:now) :format '(:year "-" (:month 2) "-" (:day 2))) |
||
;; => "2019-11-13" |
;; => "2019-11-13" |
||
(local-time:format-timestring nil (local-time:now) :format '(:long-weekday ", " :long-month #\space (:day 2) ", " :year)) |
(local-time:format-timestring nil (local-time:now) :format '(:long-weekday ", " :long-month #\space (:day 2) ", " :year)) |
||
;; => "Wednesday, November 13, 2019" |
;; => "Wednesday, November 13, 2019" |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Component Pascal}}== |
=={{header|Component Pascal}}== |
||
BlackBox Component Builder |
BlackBox Component Builder |
||
< |
<syntaxhighlight lang="oberon2"> |
||
MODULE DateFormat; |
MODULE DateFormat; |
||
IMPORT StdLog, Dates; |
IMPORT StdLog, Dates; |
||
Line 1,446: | Line 1,646: | ||
END Do; |
END Do; |
||
END DateFormat. |
END DateFormat. |
||
</syntaxhighlight> |
|||
</lang> |
|||
Execute: ^Q DateFormat.Do<br/> |
Execute: ^Q DateFormat.Do<br/> |
||
{{out}} |
{{out}} |
||
Line 1,460: | Line 1,660: | ||
=={{header|Crystal}}== |
=={{header|Crystal}}== |
||
{{works with|Crystal|0.33}} |
{{works with|Crystal|0.33}} |
||
< |
<syntaxhighlight lang="crystal">require "time" |
||
time = Time.local |
time = Time.local |
||
puts time.to_s("%Y-%m-%d") |
puts time.to_s("%Y-%m-%d") |
||
puts time.to_s("%A, %B %d, %Y") |
puts time.to_s("%A, %B %d, %Y") |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|D}}== |
=={{header|D}}== |
||
{{works with|D|DMD 1.026}} |
{{works with|D|DMD 1.026}} |
||
{{libheader|Tango}} |
{{libheader|Tango}} |
||
< |
<syntaxhighlight lang="d">module datetimedemo ; |
||
import tango.time.Time ; |
import tango.time.Time ; |
||
Line 1,486: | Line 1,686: | ||
d = g.toTime(2008, 2, 1, 0, 0, 0, 0, g.AD_ERA) ; |
d = g.toTime(2008, 2, 1, 0, 0, 0, 0, g.AD_ERA) ; |
||
Stdout.format("{:dddd, MMMM d, yyy}", d).newline ; |
Stdout.format("{:dddd, MMMM d, yyy}", d).newline ; |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>2007-11-10 |
<pre>2007-11-10 |
||
Line 1,493: | Line 1,693: | ||
=={{header|Delphi}}== |
=={{header|Delphi}}== |
||
< |
<syntaxhighlight lang="delphi">ShowMessage(FormatDateTime('yyyy-mm-dd', Now) +#13#10+ FormatDateTime('dddd, mmmm dd, yyyy', Now));</syntaxhighlight> |
||
{{out}} |
|||
<pre> |
|||
2022-02-16 |
|||
Wednesday, February 16, 2022 |
|||
Redirecting to |
|||
</pre> |
|||
=={{header|Diego}}== |
|||
<syntaxhighlight lang="diego">me_lang(en)_cal(gregorian); |
|||
me_msg()_now()_format(yyyy-mm-dd); |
|||
me_msg()_now()_format(eeee, mmmm dd, yyyy);</syntaxhighlight> |
|||
=={{header|EasyLang}}== |
|||
<syntaxhighlight lang=text> |
|||
func wkday year month day . |
|||
adj = (14 - month) div 12 |
|||
mm = month + 12 * adj - 2 |
|||
yy = year - adj |
|||
r = day + (13 * mm - 1) div 5 + yy + yy div 4 - yy div 100 + yy div 400 |
|||
return r mod 7 + 1 |
|||
. |
|||
month$[] = [ "January" "February" "March" "April" "May" "June" "July" "August" "September" "October" "November" "December" ] |
|||
wday$[] = [ "Sunday" "Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday" ] |
|||
# |
|||
s$ = timestr systime |
|||
y$ = substr s$ 1 4 |
|||
y = number y$ |
|||
m$ = substr s$ 6 2 |
|||
m = number m$ |
|||
d$ = substr s$ 9 2 |
|||
d = number d$ |
|||
# |
|||
print y$ & "-" & m$ & "-" & d$ |
|||
print wday$[wkday y m d] & ", " & month$[m] & " " & d & ", " & y |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2024-07-22 |
|||
Monday, July 22, 2024 |
|||
</pre> |
|||
=={{header|Ed}}== |
|||
Using <tt>date</tt> is cheating, but ed has no built-in date fetching/formatting. Most other languages use strftime, which is basically the same thing, anyway. |
|||
<syntaxhighlight lang="sed"> |
|||
H |
|||
!date +"\%Y-\%m-\%d" |
|||
!date +"\%A, \%B \%d, \%Y" |
|||
Q |
|||
</syntaxhighlight> |
|||
=={{header|EGL}}== |
=={{header|EGL}}== |
||
<syntaxhighlight lang="egl"> |
|||
<lang EGL> |
|||
// 2012-09-26 |
// 2012-09-26 |
||
SysLib.writeStdout(StrLib.formatDate(DateTimeLib.currentDate(), "yyyy-MM-dd")); |
SysLib.writeStdout(StrLib.formatDate(DateTimeLib.currentDate(), "yyyy-MM-dd")); |
||
Line 1,502: | Line 1,753: | ||
SysLib.setLocale("en", "US"); |
SysLib.setLocale("en", "US"); |
||
SysLib.writeStdout(StrLib.formatDate(DateTimeLib.currentDate(), "EEEE, MMMM dd, yyyy")); |
SysLib.writeStdout(StrLib.formatDate(DateTimeLib.currentDate(), "EEEE, MMMM dd, yyyy")); |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 1,512: | Line 1,763: | ||
{{trans|Erlang}} |
{{trans|Erlang}} |
||
{{works with|Elixir|1.4}} |
{{works with|Elixir|1.4}} |
||
< |
<syntaxhighlight lang="elixir">defmodule Date_format do |
||
def iso_date, do: Date.utc_today |> Date.to_iso8601 |
def iso_date, do: Date.utc_today |> Date.to_iso8601 |
||
Line 1,534: | Line 1,785: | ||
IO.puts Date_format.long_date |
IO.puts Date_format.long_date |
||
IO.puts Date_format.iso_date(2007,11,10) |
IO.puts Date_format.iso_date(2007,11,10) |
||
IO.puts Date_format.long_date(2007,11,10)</ |
IO.puts Date_format.long_date(2007,11,10)</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 1,545: | Line 1,796: | ||
=={{header|Emacs Lisp}}== |
=={{header|Emacs Lisp}}== |
||
< |
<syntaxhighlight lang="lisp">(format-time-string "%Y-%m-%d") |
||
(format-time-string "%F") ;; new in Emacs 24 |
(format-time-string "%F") ;; new in Emacs 24 |
||
=> "2015-11-08" |
;; => "2015-11-08" |
||
(format-time-string "%A, %B %e, %Y") |
(format-time-string "%A, %B %e, %Y") |
||
=> "Sunday, November 8, 2015" |
;; => "Sunday, November 8, 2015"</syntaxhighlight> |
||
</lang> |
|||
<code>%e</code> is blank-padded day number, or <code>%d</code> for zero-padded. Month and weekday names follow the current locale. On a POSIX style system this is the usual <code>LC_TIME</code> or <code>LC_ALL</code> environment variables. GNU Emacs variable <code>system-time-locale</code> can override this if desired. |
<code>%e</code> is blank-padded day number, or <code>%d</code> for zero-padded. Month and weekday names follow the current locale. On a POSIX style system this is the usual <code>LC_TIME</code> or <code>LC_ALL</code> environment variables. GNU Emacs variable <code>system-time-locale</code> can override this if desired. |
||
Line 1,557: | Line 1,807: | ||
=={{header|Erlang}}== |
=={{header|Erlang}}== |
||
< |
<syntaxhighlight lang="erlang">-module(format_date). |
||
-export([iso_date/0, iso_date/1, iso_date/3, long_date/0, long_date/1, long_date/3]). |
-export([iso_date/0, iso_date/1, iso_date/3, long_date/0, long_date/1, long_date/3]). |
||
-import(calendar,[day_of_the_week/1]). |
-import(calendar,[day_of_the_week/1]). |
||
Line 1,580: | Line 1,830: | ||
MonthName = element(Month, Months), |
MonthName = element(Month, Months), |
||
append([WeekdayName, ", ", MonthName, " ", integer_to_list(Day), ", ", |
append([WeekdayName, ", ", MonthName, " ", integer_to_list(Day), ", ", |
||
integer_to_list(Year)]).</ |
integer_to_list(Year)]).</syntaxhighlight> |
||
=={{header|Euphoria}}== |
=={{header|Euphoria}}== |
||
< |
<syntaxhighlight lang="euphoria">constant days = {"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"} |
||
constant months = {"January","February","March","April","May","June", |
constant months = {"January","February","March","April","May","June", |
||
"July","August","September","October","November","December"} |
"July","August","September","October","November","December"} |
||
Line 1,593: | Line 1,843: | ||
printf(1,"%d-%02d-%02d\n",now[1..3]) |
printf(1,"%d-%02d-%02d\n",now[1..3]) |
||
printf(1,"%s, %s %d, %d\n",{days[now[7]],months[now[2]],now[3],now[1]})</ |
printf(1,"%s, %s %d, %d\n",{days[now[7]],months[now[2]],now[3],now[1]})</syntaxhighlight> |
||
=={{header|F_Sharp|F#}}== |
=={{header|F_Sharp|F#}}== |
||
"F# Interactive" session: |
"F# Interactive" session: |
||
< |
<syntaxhighlight lang="fsharp">> open System;; |
||
> Console.WriteLine( DateTime.Now.ToString("yyyy-MM-dd") );; |
> Console.WriteLine( DateTime.Now.ToString("yyyy-MM-dd") );; |
||
2010-08-13 |
2010-08-13 |
||
> Console.WriteLine( "{0:D}", DateTime.Now );; |
> Console.WriteLine( "{0:D}", DateTime.Now );; |
||
Friday, August 13, 2010</ |
Friday, August 13, 2010</syntaxhighlight> |
||
=={{header|Factor}}== |
=={{header|Factor}}== |
||
< |
<syntaxhighlight lang="factor">USING: formatting calendar io ; |
||
now "%Y-%m-%d" strftime print |
now "%Y-%m-%d" strftime print |
||
now "%A, %B %d, %Y" strftime print</ |
now "%A, %B %d, %Y" strftime print</syntaxhighlight> |
||
=={{header|Fantom}}== |
=={{header|Fantom}}== |
||
Line 1,613: | Line 1,863: | ||
Today's date can be retrieved using 'Date.today'. The 'toLocale' method can be passed formatting information to determine how the date should be represented as a string. The rules are described at http://fantom.org/doc/sys/Date.html#toLocale |
Today's date can be retrieved using 'Date.today'. The 'toLocale' method can be passed formatting information to determine how the date should be represented as a string. The rules are described at http://fantom.org/doc/sys/Date.html#toLocale |
||
< |
<syntaxhighlight lang="fantom"> |
||
fansh> Date.today.toLocale("YYYY-MM-DD") |
fansh> Date.today.toLocale("YYYY-MM-DD") |
||
2011-02-24 |
2011-02-24 |
||
fansh> Date.today.toLocale("WWWW, MMMM DD, YYYY") |
fansh> Date.today.toLocale("WWWW, MMMM DD, YYYY") |
||
Thursday, February 24, 2011 |
Thursday, February 24, 2011 |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Forth}}== |
=={{header|Forth}}== |
||
< |
<syntaxhighlight lang="forth">: .-0 ( n -- n ) |
||
[char] - emit |
[char] - emit |
||
dup 10 < if [char] 0 emit then ; |
dup 10 < if [char] 0 emit then ; |
||
Line 1,675: | Line 1,925: | ||
3dup weekday weekdays type ." , " |
3dup weekday weekdays type ." , " |
||
>R 1- months type space 1 u.r ." , " R> . |
>R 1- months type space 1 u.r ." , " R> . |
||
drop drop drop ;</ |
drop drop drop ;</syntaxhighlight> |
||
=== Version 2: Meta Language === |
=== Version 2: Meta Language === |
||
Forth is less of a language and more of an extensible toolkit of simple routines. This version attempts to demonstrate using the simple routines to extend Forth. Then using the language extensions and the power of concatenative language to solve the problem. This solution could create numerous date formats as one line definitions now that we have our "date" words defined. Typically these extensions would be saved as a library file. |
Forth is less of a language and more of an extensible toolkit of simple routines. This version attempts to demonstrate using the simple routines to extend Forth. Then using the language extensions and the power of concatenative language to solve the problem. This solution could create numerous date formats as one line definitions now that we have our "date" words defined. Typically these extensions would be saved as a library file. |
||
< |
<syntaxhighlight lang="forth">\ Build up a "language" for date formatting |
||
\ utility words |
\ utility words |
||
Line 1,740: | Line 1,990: | ||
\ Rosetta Date Format 2 |
\ Rosetta Date Format 2 |
||
: LONG.DATE ( d m y -- ) |
: LONG.DATE ( d m y -- ) |
||
3DUP CDAY DOW ]DAY$. ',' -ROT ]MONTH$. SPACE ##. ',' ####. ;</ |
3DUP CDAY DOW ]DAY$. ',' -ROT ]MONTH$. SPACE ##. ',' ####. ;</syntaxhighlight> |
||
Test at the Forth Console |
Test at the Forth Console |
||
< |
<syntaxhighlight lang="forth"> 5 7 2018 Y-M-D. 2018-07-05 ok |
||
ok |
ok |
||
5 7 2018 LONG.DATE Thursday, July 05, 2018 ok |
5 7 2018 LONG.DATE Thursday, July 05, 2018 ok |
||
</syntaxhighlight> |
|||
</LANG> |
|||
=={{header|Fortran}}== |
=={{header|Fortran}}== |
||
{{works with|Fortran|95 and later}} |
{{works with|Fortran|95 and later}} |
||
The subroutine DATE_AND_TIME does not return day of week information so we have to write our own function for that |
The subroutine DATE_AND_TIME does not return day of week information so we have to write our own function for that |
||
< |
<syntaxhighlight lang="fortran">PROGRAM DATE |
||
IMPLICIT NONE |
IMPLICIT NONE |
||
Line 1,820: | Line 2,071: | ||
END FUNCTION Day_of_week |
END FUNCTION Day_of_week |
||
END PROGRAM DATE</ |
END PROGRAM DATE</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
2008-12-14 |
2008-12-14 |
||
Line 1,826: | Line 2,077: | ||
=={{header|FreeBASIC}}== |
=={{header|FreeBASIC}}== |
||
< |
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64 |
||
#Include "vbcompat.bi" |
#Include "vbcompat.bi" |
||
Line 1,835: | Line 2,086: | ||
Print |
Print |
||
Print "Press any key to quit the program" |
Print "Press any key to quit the program" |
||
Sleep</ |
Sleep</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 1,841: | Line 2,092: | ||
This example was created on : 2016-10-02 |
This example was created on : 2016-10-02 |
||
In other words on : Sunday, October 2, 2016 |
In other words on : Sunday, October 2, 2016 |
||
</pre> |
|||
=={{header|Free Pascal}}== |
|||
<syntaxhighlight lang="pascal">program Format_Date_Time; |
|||
uses |
|||
SysUtils; |
|||
begin |
|||
WriteLn(FormatDateTime('yyyy-mm-dd', Now) +#13#10+ FormatDateTime('dddd, mmmm dd, yyyy', Now)); |
|||
end. |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2022-02-16 |
|||
Wednesday, February 16, 2022 |
|||
</pre> |
</pre> |
||
=={{header|Frink}}== |
=={{header|Frink}}== |
||
< |
<syntaxhighlight lang="frink"> |
||
println[now[] -> ### yyyy-MM-dd ###] |
println[now[] -> ### yyyy-MM-dd ###] |
||
println[now[] -> ### EEEE, MMMM d, yyyy ###] |
println[now[] -> ### EEEE, MMMM d, yyyy ###] |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|FunL}}== |
=={{header|FunL}}== |
||
< |
<syntaxhighlight lang="funl">println( format('%tF', $date) ) |
||
println( format('%1$tA, %1$tB %1$td, %1$tY', $date) )</ |
println( format('%1$tA, %1$tB %1$td, %1$tY', $date) )</syntaxhighlight> |
||
=={{header|FutureBasic}}== |
|||
<syntaxhighlight lang="futurebasic">window 1 |
|||
print date(@"yyyy-MM-dd") |
|||
print date(@"EEEE, MMMM dd, yyyy") |
|||
HandleEvents</syntaxhighlight> |
|||
=={{header|Gambas}}== |
=={{header|Gambas}}== |
||
'''[https://gambas-playground.proko.eu/ You can run this code. Copy the code, click this link, paste it in and press 'Run !']''' |
'''[https://gambas-playground.proko.eu/ You can run this code. Copy the code, click this link, paste it in and press 'Run !']''' |
||
< |
<syntaxhighlight lang="gambas">Public Sub Main() |
||
Print Format(Now, "yyyy - mm - dd") |
Print Format(Now, "yyyy - mm - dd") |
||
Print Format(Now, "dddd, mmmm dd, yyyy") |
Print Format(Now, "dddd, mmmm dd, yyyy") |
||
End</ |
End</syntaxhighlight> |
||
Output: |
Output: |
||
<pre> |
<pre> |
||
Line 1,869: | Line 2,142: | ||
=={{header|Go}}== |
=={{header|Go}}== |
||
In an interesting design, you specify your format by providing the format for the date and time 01/02 03:04:05PM '06 -0700 |
In an interesting design, you specify your format by providing the format for the date and time 01/02 03:04:05PM '06 -0700 |
||
< |
<syntaxhighlight lang="go">package main |
||
import "time" |
import "time" |
||
Line 1,877: | Line 2,150: | ||
fmt.Println(time.Now().Format("2006-01-02")) |
fmt.Println(time.Now().Format("2006-01-02")) |
||
fmt.Println(time.Now().Format("Monday, January 2, 2006")) |
fmt.Println(time.Now().Format("Monday, January 2, 2006")) |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 1,886: | Line 2,159: | ||
=={{header|Groovy}}== |
=={{header|Groovy}}== |
||
Solution: |
Solution: |
||
< |
<syntaxhighlight lang="groovy">def isoFormat = { date -> date.format("yyyy-MM-dd") } |
||
def longFormat = { date -> date.format("EEEE, MMMM dd, yyyy") }</ |
def longFormat = { date -> date.format("EEEE, MMMM dd, yyyy") }</syntaxhighlight> |
||
Test Program: |
Test Program: |
||
< |
<syntaxhighlight lang="groovy">def now = new Date() |
||
println isoFormat(now) |
println isoFormat(now) |
||
println longFormat(now)</ |
println longFormat(now)</syntaxhighlight> |
||
=={{header|Haskell}}== |
=={{header|Haskell}}== |
||
< |
<syntaxhighlight lang="haskell">import Data.Time |
||
(FormatTime, formatTime, defaultTimeLocale, utcToLocalTime, |
(FormatTime, formatTime, defaultTimeLocale, utcToLocalTime, |
||
getCurrentTimeZone, getCurrentTime) |
getCurrentTimeZone, getCurrentTime) |
||
Line 1,905: | Line 2,178: | ||
main = do |
main = do |
||
t <- pure utcToLocalTime <*> getCurrentTimeZone <*> getCurrentTime |
t <- pure utcToLocalTime <*> getCurrentTimeZone <*> getCurrentTime |
||
putStrLn $ unlines (formats <*> pure t)</ |
putStrLn $ unlines (formats <*> pure t)</syntaxhighlight> |
||
'''Sample output:''' |
'''Sample output:''' |
||
<pre>2017-06-05 |
<pre>2017-06-05 |
||
Line 1,911: | Line 2,184: | ||
=={{header|HicEst}}== |
=={{header|HicEst}}== |
||
< |
<syntaxhighlight lang="hicest"> CHARACTER string*40 |
||
WRITE(Text=string, Format='UCCYY-MM-DD') 0 ! string: 2010-03-13 |
WRITE(Text=string, Format='UCCYY-MM-DD') 0 ! string: 2010-03-13 |
||
Line 1,923: | Line 2,196: | ||
EDIT(Text=string, Right=' ', Mark1, Right=';', Right=3, Mark2, Delete, Insert=', '//cMonth, Right=';', RePLaceby=',') |
EDIT(Text=string, Right=' ', Mark1, Right=';', Right=3, Mark2, Delete, Insert=', '//cMonth, Right=';', RePLaceby=',') |
||
END</ |
END</syntaxhighlight> |
||
=={{header|Icon}} and {{header|Unicon}}== |
=={{header|Icon}} and {{header|Unicon}}== |
||
< |
<syntaxhighlight lang="icon">procedure main() |
||
write(map(&date,"/","-")) |
write(map(&date,"/","-")) |
||
write(&dateline ? tab(find(&date[1:5])+4)) |
write(&dateline ? tab(find(&date[1:5])+4)) |
||
end</ |
end</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 1,937: | Line 2,210: | ||
=={{header|J}}== |
=={{header|J}}== |
||
Short format using built in formatting: |
Short format using built in formatting: |
||
< |
<syntaxhighlight lang="j"> 6!:0 'YYYY-MM-DD' |
||
2010-08-19</ |
2010-08-19</syntaxhighlight> |
||
Verb to show custom format: |
Verb to show custom format: |
||
< |
<syntaxhighlight lang="j">require 'dates system/packages/misc/datefmt.ijs' |
||
days=:;:'Sunday Monday Tuesday Wednesday Thursday Friday Saturday' |
days=:;:'Sunday Monday Tuesday Wednesday Thursday Friday Saturday' |
||
fmtDate=: [:((days ;@{~ weekday),', ',ms0) 3 {.] |
fmtDate=: [:((days ;@{~ weekday),', ',ms0) 3 {.] |
||
fmtDate 6!:0 '' |
fmtDate 6!:0 '' |
||
Thursday, August 19, 2010</ |
Thursday, August 19, 2010</syntaxhighlight> |
||
=={{header|Java}}== |
=={{header|Java}}== |
||
< |
<syntaxhighlight lang="java"> |
||
public static void main(String[] args) { |
|||
long millis = System.currentTimeMillis(); |
|||
System.out.printf("%tF%n", millis); |
|||
System.out.printf("%tA, %1$tB %1$td, %1$tY%n", millis); |
|||
} |
|||
</syntaxhighlight> |
|||
<pre> |
|||
2023-05-10 |
|||
Wednesday, May 10, 2023 |
|||
</pre> |
|||
<br /> |
|||
An alternate demonstration |
|||
<syntaxhighlight lang="java"> |
|||
import java.util.Calendar; |
import java.util.Calendar; |
||
import java.util.GregorianCalendar; |
import java.util.GregorianCalendar; |
||
Line 1,968: | Line 2,254: | ||
} |
} |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
Better: use a library, see http://sourceforge.net/apps/mediawiki/threeten/index.php?title=ThreeTen |
Better: use a library, see http://sourceforge.net/apps/mediawiki/threeten/index.php?title=ThreeTen |
||
===Java 8 Date Time API=== |
===Java 8 Date Time API=== |
||
< |
<syntaxhighlight lang="java"> |
||
import java.time.LocalDate; |
import java.time.LocalDate; |
||
import java.time.format.DateTimeFormatter; |
import java.time.format.DateTimeFormatter; |
||
Line 1,986: | Line 2,272: | ||
} |
} |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
===Java Util Date API=== |
===Java Util Date API=== |
||
< |
<syntaxhighlight lang="java"> |
||
import java.text.SimpleDateFormat; |
import java.text.SimpleDateFormat; |
||
import java.util.Date; |
import java.util.Date; |
||
Line 2,001: | Line 2,287: | ||
} |
} |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|JavaScript}}== |
=={{header|JavaScript}}== |
||
JavaScript does not have any built-in <code>strftime</code>-type functionality. |
JavaScript does not have any built-in <code>strftime</code>-type functionality. |
||
< |
<syntaxhighlight lang="javascript">var now = new Date(), |
||
weekdays = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'], |
weekdays = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'], |
||
months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'], |
months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'], |
||
Line 2,011: | Line 2,297: | ||
fmt2 = weekdays[now.getDay()] + ', ' + months[now.getMonth()] + ' ' + now.getDate() + ', ' + now.getFullYear(); |
fmt2 = weekdays[now.getDay()] + ', ' + months[now.getMonth()] + ' ' + now.getDate() + ', ' + now.getFullYear(); |
||
console.log(fmt1); |
console.log(fmt1); |
||
console.log(fmt2);</ |
console.log(fmt2);</syntaxhighlight> |
||
<pre>2010-1-12 |
<pre>2010-1-12 |
||
Tuesday, January 12, 2010</pre> |
Tuesday, January 12, 2010</pre> |
||
=={{header|Joy}}== |
=={{header|Joy}}== |
||
<syntaxhighlight lang="joy"> |
|||
<lang Joy> |
|||
DEFINE weekdays == [ |
DEFINE weekdays == ["Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday" "Sunday"]; |
||
months == [ |
months == ["January" "February" "March" "April" "May" "June" "July" "August" |
||
"September" "October" "November" "December" ]. |
|||
time localtime [ |
time localtime [[0 at 'd 4 4 format] ["-"] [1 at 'd 2 2 format] ["-"] [2 at 'd 2 2 format]] |
||
[i] map [putchars] step '\n putch pop. |
[i] map [putchars] step '\n putch pop. |
||
time localtime [ |
time localtime [[8 at pred weekdays of] [", "] [1 at pred months of] [" "] [2 at 'd 1 1 format] |
||
[", "] [0 at 'd 4 4 format] |
[", "] [0 at 'd 4 4 format]] [i] map [putchars] step '\n putch pop. |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|jq}}== |
=={{header|jq}}== |
||
{{works with|jq|with strftime}} |
{{works with|jq|with strftime}} |
||
< |
<syntaxhighlight lang="sh">$ jq -n 'now | (strftime("%Y-%m-%d"), strftime("%A, %B %d, %Y"))' |
||
"2015-07-02" |
"2015-07-02" |
||
"Thursday, July 02, 2015"</ |
"Thursday, July 02, 2015"</syntaxhighlight> |
||
WARNING: prior to July 2, 2015, there was a bug in jq affecting the display of the "day of week" (wday) and the "day of the year" (yday). |
WARNING: prior to July 2, 2015, there was a bug in jq affecting the display of the "day of week" (wday) and the "day of the year" (yday). |
||
Line 2,039: | Line 2,325: | ||
{{works with|Julia|0.6}} |
{{works with|Julia|0.6}} |
||
< |
<syntaxhighlight lang="julia">ts = Dates.today() |
||
println("Today's date is:") |
println("Today's date is:") |
||
println("\t$ts") |
println("\t$ts") |
||
println("\t", Dates.format(ts, "E, U dd, yyyy"))</ |
println("\t", Dates.format(ts, "E, U dd, yyyy"))</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 2,051: | Line 2,337: | ||
=={{header|Kotlin}}== |
=={{header|Kotlin}}== |
||
< |
<syntaxhighlight lang="scala">// version 1.0.6 |
||
import java.util.GregorianCalendar |
import java.util.GregorianCalendar |
||
Line 2,059: | Line 2,345: | ||
println("%tF".format(now)) |
println("%tF".format(now)) |
||
println("%tA, %1\$tB %1\$te, %1\$tY".format(now)) |
println("%tA, %1\$tB %1\$te, %1\$tY".format(now)) |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 2,068: | Line 2,354: | ||
=={{header|langur}}== |
=={{header|langur}}== |
||
<syntaxhighlight lang="langur">writeln string(dt//, "2006-01-02") |
|||
{{works with|langur|0.10.1}} |
|||
writeln string(dt//, "Monday, January 2, 2006") |
|||
<lang langur>var .now = dt// |
|||
</syntaxhighlight> |
|||
var .format1 = "2006-01-02" |
|||
var .format2 = "Monday, January 2, 2006" |
|||
writeln $"\.now:dt.format1;" |
|||
writeln $"\.now:dt.format2;"</lang> |
|||
<syntaxhighlight lang="langur"> |
|||
{{works with|langur|0.9.3}} |
|||
writeln "{{dt//:dt(2006-01-02)}}" |
|||
<lang langur>var .now = dt// |
|||
writeln |
writeln "{{dt//:dt(Monday, January 2, 2006)}}" |
||
</syntaxhighlight> |
|||
writeln $"\.now:dt(Monday, January 2, 2006);"</lang> |
|||
{{works with|langur|0.9}} |
|||
<lang langur>writeln toString dt//, "2006-01-02" |
|||
writeln toString dt//, "Monday, January 2, 2006"</lang> |
|||
{{out}} |
{{out}} |
||
<pre>2020-03-26 |
<pre>2020-03-26 |
||
Thursday, March 26, 2020</pre> |
Thursday, March 26, 2020</pre> |
||
Langur is using the Go time package, and using its formatting method for output. It expects the following parts in a format string. |
|||
<pre>year: 2006 or 06 |
|||
month: 01 or 1 |
|||
month name: Jan or January |
|||
month day: 02 or _2 or 2 |
|||
weekday name: Mon or Monday |
|||
hour: 03 or 3 or 15 |
|||
minute: 04 or 4 |
|||
second: 05 or 5 |
|||
AM/PM: PM or pm |
|||
time zone offset: -07:00 or -0700 or -07 |
|||
time zone name: MST</pre> |
|||
=={{header|Lasso}}== |
=={{header|Lasso}}== |
||
<syntaxhighlight lang="lasso"> |
|||
<lang Lasso> |
|||
date('11/10/2007')->format('%Q') // 2007-11-10 |
date('11/10/2007')->format('%Q') // 2007-11-10 |
||
date('11/10/2007')->format('EEEE, MMMM d, YYYY') //Saturday, November 10, 2007 |
date('11/10/2007')->format('EEEE, MMMM d, YYYY') //Saturday, November 10, 2007 |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Liberty BASIC}}== |
=={{header|Liberty BASIC}}== |
||
< |
<syntaxhighlight lang="lb">'Display the current date in the formats of "2007-11-10" |
||
d$=date$("yyyy/mm/dd") |
d$=date$("yyyy/mm/dd") |
||
print word$(d$,1,"/")+"-"+word$(d$,2,"/")+"-"+word$(d$,3,"/") |
print word$(d$,1,"/")+"-"+word$(d$,2,"/")+"-"+word$(d$,3,"/") |
||
Line 2,132: | Line 2,397: | ||
monthLong$="January February March April May June July August September October November December" |
monthLong$="January February March April May June July August September October November December" |
||
print word$(weekDay$,theDay+1);", ";word$(monthLong$,month);" ";day;", ";year</ |
print word$(weekDay$,theDay+1);", ";word$(monthLong$,month);" ";day;", ";year</syntaxhighlight> |
||
=={{header|LiveCode}}== |
|||
<syntaxhighlight lang="livecode">on mouseUp pButtonNumber |
|||
put the date into tDate |
|||
convert tDate to dateItems |
|||
put item 1 of tDate & "-" & item 2 of tDate & "-" & item 3 of tDate & return into tMyFormattedDate |
|||
put tMyFormattedDate & the long date |
|||
end mouseUp </syntaxhighlight> |
|||
=={{header|Logo}}== |
=={{header|Logo}}== |
||
{{works with|UCB Logo}} |
{{works with|UCB Logo}} |
||
A bit of a cheat since Logo has no standard built-in time and date functions, but UCB Logo can call out to the shell, so: |
A bit of a cheat since Logo has no standard built-in time and date functions, but UCB Logo can call out to the shell, so: |
||
< |
<syntaxhighlight lang="logo"> |
||
print first shell [date +%F] |
print first shell [date +%F] |
||
print first shell [date +"%A, %B %d, %Y"] |
print first shell [date +"%A, %B %d, %Y"] |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{Out}} |
{{Out}} |
||
<pre>2020-09-16 |
<pre>2020-09-16 |
||
Line 2,146: | Line 2,420: | ||
=={{header|Lua}}== |
=={{header|Lua}}== |
||
< |
<syntaxhighlight lang="lua">print( os.date( "%Y-%m-%d" ) ) |
||
print( os.date( "%A, %B %d, %Y" ) )</ |
print( os.date( "%A, %B %d, %Y" ) )</syntaxhighlight> |
||
=={{header|M2000 Interpreter}}== |
=={{header|M2000 Interpreter}}== |
||
<syntaxhighlight lang="m2000 interpreter"> |
|||
<lang M2000 Interpreter> |
|||
Print str$(today, "yyyy-mm-dd") |
Print str$(today, "yyyy-mm-dd") |
||
Print str$(today, "dddd, mmm, dd, yyyy") |
Print str$(today, "dddd, mmm, dd, yyyy") |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Maple}}== |
=={{header|Maple}}== |
||
<syntaxhighlight lang="maple"> |
|||
<lang Maple> |
|||
with(StringTools); |
with(StringTools); |
||
FormatTime("%Y-%m-%d") |
FormatTime("%Y-%m-%d") |
||
FormatTime("%A,%B %d, %y") |
FormatTime("%A,%B %d, %y") |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Mathematica}}== |
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
||
< |
<syntaxhighlight lang="mathematica">DateString[{"Year", "-", "Month", "-", "Day"}] |
||
DateString[{"DayName", ", ", "MonthName", " ", "Day", ", ", "Year"}]</ |
DateString[{"DayName", ", ", "MonthName", " ", "Day", ", ", "Year"}]</syntaxhighlight> |
||
=={{header|MATLAB}} / {{header|Octave}}== |
=={{header|MATLAB}} / {{header|Octave}}== |
||
< |
<syntaxhighlight lang="matlab">>> datestr(now,'yyyy-mm-dd') |
||
ans = |
ans = |
||
Line 2,178: | Line 2,452: | ||
ans = |
ans = |
||
Friday, June 18, 2010</ |
Friday, June 18, 2010</syntaxhighlight> |
||
=={{header|min}}== |
=={{header|min}}== |
||
{{works with|min|0.19.3}} |
{{works with|min|0.19.3}} |
||
< |
<syntaxhighlight lang="min">("YYYY-MM-dd" "dddd, MMMM dd, YYYY") ('timestamp dip tformat puts!) foreach</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
2019-04-02 |
2019-04-02 |
||
Tuesday, April 02, 2019 |
Tuesday, April 02, 2019 |
||
</pre> |
|||
=={{header|MiniScript}}== |
|||
<syntaxhighlight lang="miniscript">import "dateTime" |
|||
print dateTime.now("yyyy-MM-dd") |
|||
print dateTime.now("dddd, MMMM d, yyyy")</syntaxhighlight> |
|||
{{out}} |
|||
<pre>2023-12-28 |
|||
Thursday, December 28, 2023 |
|||
</pre> |
</pre> |
||
=={{header|mIRC Scripting Language}}== |
=={{header|mIRC Scripting Language}}== |
||
< |
<syntaxhighlight lang="mirc">echo -ag $time(yyyy-mm-dd) |
||
echo -ag $time(dddd $+ $chr(44) mmmm dd $+ $chr(44) yyyy)</ |
echo -ag $time(dddd $+ $chr(44) mmmm dd $+ $chr(44) yyyy)</syntaxhighlight> |
||
=={{header|MUMPS}}== |
=={{header|MUMPS}}== |
||
{{works with|MUMPS|Intersystems' Caché|(all versions)}} |
{{works with|MUMPS|Intersystems' Caché|(all versions)}} |
||
Functions starting with 'Z' or '$Z' are implementation specific. |
Functions starting with 'Z' or '$Z' are implementation specific. |
||
< |
<syntaxhighlight lang="mumps">DTZ |
||
WRITE !,"Date format 3: ",$ZDATE($H,3) |
WRITE !,"Date format 3: ",$ZDATE($H,3) |
||
WRITE !,"Or ",$ZDATE($H,12),", ",$ZDATE($H,9) |
WRITE !,"Or ",$ZDATE($H,12),", ",$ZDATE($H,9) |
||
QUIT</ |
QUIT</syntaxhighlight> |
||
<p>MUMPS contains the integer number of days since December 31, 1840 in the first part of the system variable $HOROLOG.</p> |
<p>MUMPS contains the integer number of days since December 31, 1840 in the first part of the system variable $HOROLOG.</p> |
||
{{works with|MUMPS|all}} |
{{works with|MUMPS|all}} |
||
< |
<syntaxhighlight lang="mumps">DTM(H) |
||
;You can pass an integer, but the default is to use today's value |
;You can pass an integer, but the default is to use today's value |
||
SET:$DATA(H)=0 H=$HOROLOG |
SET:$DATA(H)=0 H=$HOROLOG |
||
Line 2,222: | Line 2,507: | ||
WRITE !,$P(DN,",",DOW),", ",$P(MN,",",MO)," ",DA,", ",YR |
WRITE !,$P(DN,",",DOW),", ",$P(MN,",",MO)," ",DA,", ",YR |
||
KILL Y,YR,RD,MC,MO,DA,MN,DN,DOW |
KILL Y,YR,RD,MC,MO,DA,MN,DN,DOW |
||
QUIT</ |
QUIT</syntaxhighlight> |
||
Demos:<pre> |
Demos:<pre> |
||
USER>D DTM^ROSETTA |
USER>D DTM^ROSETTA |
||
Line 2,239: | Line 2,524: | ||
=={{header|Nanoquery}}== |
=={{header|Nanoquery}}== |
||
< |
<syntaxhighlight lang="nanoquery">import Nanoquery.Util |
||
d = new(Date) |
d = new(Date) |
||
println d.getYear() + "-" + d.getMonth() + "-" + d.getDay() |
println d.getYear() + "-" + d.getMonth() + "-" + d.getDay() |
||
println d.getDayOfWeek() + ", " + d.getMonthName() + " " + d.getDay() + ", " + d.getYear()</ |
println d.getDayOfWeek() + ", " + d.getMonthName() + " " + d.getDay() + ", " + d.getYear()</syntaxhighlight> |
||
=={{header|Neko}}== |
=={{header|Neko}}== |
||
<syntaxhighlight lang="actionscript">/** |
|||
<lang ActionScript>/** |
|||
<doc> |
<doc> |
||
<h2>Date format</h2> |
<h2>Date format</h2> |
||
Line 2,259: | Line 2,544: | ||
var now = date_now() |
var now = date_now() |
||
$print(date_format(now, "%F"), "\n") |
$print(date_format(now, "%F"), "\n") |
||
$print(date_format(now, "%A, %B %d, %Y"), "\n")</ |
$print(date_format(now, "%A, %B %d, %Y"), "\n")</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>prompt$ nekoc date-format.neko |
<pre>prompt$ nekoc date-format.neko |
||
Line 2,267: | Line 2,552: | ||
=={{header|NetRexx}}== |
=={{header|NetRexx}}== |
||
<syntaxhighlight lang="netrexx"> |
|||
<lang NetRexx> |
|||
import java.text.SimpleDateFormat |
import java.text.SimpleDateFormat |
||
say SimpleDateFormat("yyyy-MM-dd").format(Date()) |
say SimpleDateFormat("yyyy-MM-dd").format(Date()) |
||
say SimpleDateFormat("EEEE, MMMM dd, yyyy").format(Date()) |
say SimpleDateFormat("EEEE, MMMM dd, yyyy").format(Date()) |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre>2019-02-10 |
<pre>2019-02-10 |
||
Line 2,277: | Line 2,562: | ||
=={{header|NewLISP}}== |
=={{header|NewLISP}}== |
||
< |
<syntaxhighlight lang="newlisp">; file: date-format.lsp |
||
; url: http://rosettacode.org/wiki/Date_format |
; url: http://rosettacode.org/wiki/Date_format |
||
; author: oofoe 2012-02-01 |
; author: oofoe 2012-02-01 |
||
Line 2,310: | Line 2,595: | ||
(println "long: " (date (date-value) 0 "%A, %B %#d, %Y")) |
(println "long: " (date (date-value) 0 "%A, %B %#d, %Y")) |
||
(exit)</ |
(exit)</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 2,320: | Line 2,605: | ||
=={{header|Nim}}== |
=={{header|Nim}}== |
||
< |
<syntaxhighlight lang="nim">import times |
||
var t = now() |
var t = now() |
||
echo(t.format("yyyy-MM-dd")) |
echo(t.format("yyyy-MM-dd")) |
||
echo(t.format("dddd',' MMMM d',' yyyy"))</ |
echo(t.format("dddd',' MMMM d',' yyyy"))</syntaxhighlight> |
||
=={{header|Nu}}== |
|||
{{works with|Nushell|0.96.1}} |
|||
<syntaxhighlight lang="nu">let now = date now |
|||
['%F' '%A, %B %e, %Y'] | each {|fmt| $now | format date $fmt }</syntaxhighlight> |
|||
=={{header|Objeck}}== |
=={{header|Objeck}}== |
||
< |
<syntaxhighlight lang="objeck"> |
||
use IO; |
use IO; |
||
use Time; |
use Time; |
||
Line 2,343: | Line 2,634: | ||
} |
} |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
Line 2,352: | Line 2,643: | ||
=={{header|Objective-C}}== |
=={{header|Objective-C}}== |
||
< |
<syntaxhighlight lang="objc">NSLog(@"%@", [NSDate date]); |
||
NSLog(@"%@", [[NSDate date] descriptionWithCalendarFormat:@"%Y-%m-%d" timeZone:nil locale:nil]); |
NSLog(@"%@", [[NSDate date] descriptionWithCalendarFormat:@"%Y-%m-%d" timeZone:nil locale:nil]); |
||
NSLog(@"%@", [[NSDate date] descriptionWithCalendarFormat:@"%A, %B %d, %Y" timeZone:nil locale:nil]);</ |
NSLog(@"%@", [[NSDate date] descriptionWithCalendarFormat:@"%A, %B %d, %Y" timeZone:nil locale:nil]);</syntaxhighlight> |
||
{{works with|Mac OS X|10.4+}} |
{{works with|Mac OS X|10.4+}} |
||
{{works with|iOS}} |
{{works with|iOS}} |
||
< |
<syntaxhighlight lang="objc">NSLog(@"%@", [NSDate date]); |
||
NSDateFormatter *dateFormatter = [[NSDateFormat alloc] init]; |
NSDateFormatter *dateFormatter = [[NSDateFormat alloc] init]; |
||
[dateFormatter setDateFormat:@"yyyy-MM-dd"]; |
[dateFormatter setDateFormat:@"yyyy-MM-dd"]; |
||
NSLog(@"%@", [dateFormatter stringFromDate:[NSDate date]]); |
NSLog(@"%@", [dateFormatter stringFromDate:[NSDate date]]); |
||
[dateFormatter setDateFormat:@"EEEE, MMMM d, yyyy"]; |
[dateFormatter setDateFormat:@"EEEE, MMMM d, yyyy"]; |
||
NSLog(@"%@", [dateFormatter stringFromDate:[NSDate date]]);</ |
NSLog(@"%@", [dateFormatter stringFromDate:[NSDate date]]);</syntaxhighlight> |
||
=={{header|OCaml}}== |
=={{header|OCaml}}== |
||
< |
<syntaxhighlight lang="ocaml"># #load "unix.cma";; |
||
# open Unix;; |
# open Unix;; |
||
Line 2,379: | Line 2,670: | ||
# Printf.sprintf "%d-%02d-%02d" (1900 + gmt.tm_year) (1 + gmt.tm_mon) gmt.tm_mday ;; |
# Printf.sprintf "%d-%02d-%02d" (1900 + gmt.tm_year) (1 + gmt.tm_mon) gmt.tm_mday ;; |
||
- : string = "2008-08-29"</ |
- : string = "2008-08-29"</syntaxhighlight> |
||
< |
<syntaxhighlight lang="ocaml">let months = [| "January"; "February"; "March"; "April"; "May"; "June"; |
||
"July"; "August"; "September"; "October"; "November"; "December" |] |
"July"; "August"; "September"; "October"; "November"; "December" |] |
||
Line 2,392: | Line 2,683: | ||
gmt.tm_mday |
gmt.tm_mday |
||
(1900 + gmt.tm_year) ;; |
(1900 + gmt.tm_year) ;; |
||
- : string = "Friday, August 29, 2008"</ |
- : string = "Friday, August 29, 2008"</syntaxhighlight> |
||
=={{header|ooRexx}}== |
=={{header|ooRexx}}== |
||
< |
<syntaxhighlight lang="oorexx">/* REXX */ |
||
dats='20071123' |
dats='20071123' |
||
Say date('I',dats,'S') |
Say date('I',dats,'S') |
||
Line 2,402: | Line 2,693: | ||
dati=date('I') |
dati=date('I') |
||
Say dati |
Say dati |
||
Say date('W',dati,'I')',' date('M',dati,'I') translate('ij, abcd',dati,'abcdefghij')</ |
Say date('W',dati,'I')',' date('M',dati,'I') translate('ij, abcd',dati,'abcdefghij')</syntaxhighlight> |
||
{{out}}2007-11-23 |
{{out}}2007-11-23 |
||
Friday, November 23, 2007 |
Friday, November 23, 2007 |
||
Line 2,410: | Line 2,701: | ||
=={{header|OxygenBasic}}== |
=={{header|OxygenBasic}}== |
||
< |
<syntaxhighlight lang="oxygenbasic"> |
||
extern lib "kernel32.dll" |
extern lib "kernel32.dll" |
||
Line 2,442: | Line 2,733: | ||
print "" t.wYear "-" month "-" day |
print "" t.wYear "-" month "-" day |
||
print WeekDay[t.wDayOfWeek+1 and 7 ] " " MonthName[t.wMonth and 31] " " t.wDay " " t.wYear |
print WeekDay[t.wDayOfWeek+1 and 7 ] " " MonthName[t.wMonth and 31] " " t.wDay " " t.wYear |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Oz}}== |
=={{header|Oz}}== |
||
Getting the current local date is easy, but we have to do the formatting manually. |
Getting the current local date is easy, but we have to do the formatting manually. |
||
< |
<syntaxhighlight lang="oz">declare |
||
WeekDays = unit(0:"Sunday" "Monday" "Tuesday" "Wednesday" |
WeekDays = unit(0:"Sunday" "Monday" "Tuesday" "Wednesday" |
||
"Thursday" "Friday" "Saturday") |
"Thursday" "Friday" "Saturday") |
||
Line 2,471: | Line 2,762: | ||
in |
in |
||
{System.showInfo {DateISO {OS.localTime}}} |
{System.showInfo {DateISO {OS.localTime}}} |
||
{System.showInfo {DateLong {OS.localTime}}}</ |
{System.showInfo {DateLong {OS.localTime}}}</syntaxhighlight> |
||
=={{header|Pascal}}== |
=={{header|Pascal}}== |
||
{{works with|Turbo Pascal|5.5}} |
{{works with|Turbo Pascal|5.5}} |
||
< |
<syntaxhighlight lang="pascal">program dateform; |
||
uses DOS; |
uses DOS; |
||
Line 2,529: | Line 2,820: | ||
mname := m2s(mo); dname := d2s(dow); |
mname := m2s(mo); dname := d2s(dow); |
||
writeln(dname,', ',mname,' ',dy,', ',yr) |
writeln(dname,', ',mname,' ',dy,', ',yr) |
||
end.</ |
end.</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>2010-07-30 |
<pre>2010-07-30 |
||
Friday, July 30, 2010</pre> |
Friday, July 30, 2010</pre> |
||
=={{header|PascalABC.NET}}== |
|||
<syntaxhighlight lang="delphi"> |
|||
begin |
|||
var today := DateTime.Now; |
|||
Println(today.ToString('yyyy-MM-dd')); |
|||
Println($'{today:D}'); |
|||
end. |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2024-06-01 |
|||
Saturday, June 1, 2024 |
|||
</pre> |
|||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
{{libheader|POSIX}} |
{{libheader|POSIX}} |
||
< |
<syntaxhighlight lang="perl">use POSIX; |
||
print strftime('%Y-%m-%d', 0, 0, 0, 10, 10, 107), "\n"; |
print strftime('%Y-%m-%d', 0, 0, 0, 10, 10, 107), "\n"; |
||
print strftime('%A, %B %d, %Y', 0, 0, 0, 10, 10, 107), "\n";</ |
print strftime('%A, %B %d, %Y', 0, 0, 0, 10, 10, 107), "\n";</syntaxhighlight> |
||
{{out}} with locales '''C''': |
{{out}} with locales '''C''': |
||
Line 2,551: | Line 2,856: | ||
Actual date: |
Actual date: |
||
< |
<syntaxhighlight lang="perl">use POSIX; |
||
print strftime('%Y-%m-%d', localtime), "\n"; |
print strftime('%Y-%m-%d', localtime), "\n"; |
||
print strftime('%A, %B %d, %Y', localtime), "\n";</ |
print strftime('%A, %B %d, %Y', localtime), "\n";</syntaxhighlight> |
||
{{out}} with locales '''C''': |
{{out}} with locales '''C''': |
||
Line 2,561: | Line 2,866: | ||
=={{header|Phix}}== |
=={{header|Phix}}== |
||
{{libheader|Phix/basics}} |
|||
<lang Phix>include builtins\timedate.e |
|||
<!--<syntaxhighlight lang="phix">(phixonline)--> |
|||
?format_timedate(date(),"YYYY-MM-DD") |
|||
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> |
|||
?format_timedate(date(),"Dddd, Mmmm d, YYYY")</lang> |
|||
<span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">\</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;">"YYYY-MM-DD"</span><span style="color: #0000FF;">)</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 d, YYYY"</span><span style="color: #0000FF;">)</span> |
|||
<!--</syntaxhighlight>--> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 2,572: | Line 2,881: | ||
=={{header|PHP}}== |
=={{header|PHP}}== |
||
Formatting rules: http://www.php.net/date |
Formatting rules: http://www.php.net/date |
||
< |
<syntaxhighlight lang="php"><?php |
||
echo date('Y-m-d', time())."\n"; |
echo date('Y-m-d', time())."\n"; |
||
echo date('l, F j, Y', time())."\n"; |
echo date('l, F j, Y', time())."\n"; |
||
?></ |
?></syntaxhighlight> |
||
=={{header|PicoLisp}}== |
=={{header|PicoLisp}}== |
||
< |
<syntaxhighlight lang="picolisp">(let (Date (date) Lst (date Date)) |
||
(prinl (dat$ Date "-")) # 2010-02-19 |
(prinl (dat$ Date "-")) # 2010-02-19 |
||
(prinl # Friday, February 19, 2010 |
(prinl # Friday, February 19, 2010 |
||
Line 2,587: | Line 2,896: | ||
(caddr Lst) |
(caddr Lst) |
||
", " |
", " |
||
(car Lst) ) )</ |
(car Lst) ) )</syntaxhighlight> |
||
=={{header|Pike}}== |
=={{header|Pike}}== |
||
<syntaxhighlight lang="pike"> |
|||
<lang Pike> |
|||
object cal = Calendar.ISO.Day(); |
object cal = Calendar.ISO.Day(); |
||
write( cal->format_ymd() +"\n" ); |
write( cal->format_ymd() +"\n" ); |
||
Line 2,599: | Line 2,908: | ||
cal->year_no()); |
cal->year_no()); |
||
write( special +"\n" ); |
write( special +"\n" ); |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{Out}} |
{{Out}} |
||
<pre> |
<pre> |
||
Line 2,608: | Line 2,917: | ||
=={{header|PL/I}}== |
=={{header|PL/I}}== |
||
===Version 1=== |
===Version 1=== |
||
< |
<syntaxhighlight lang="pli">df: proc Options(main); |
||
declare day_of_week(7) character (9) varying initial( |
declare day_of_week(7) character (9) varying initial( |
||
'Sunday','Monday','Tuesday','Wednesday', |
'Sunday','Monday','Tuesday','Wednesday', |
||
Line 2,622: | Line 2,931: | ||
put edit(substr(today,1,3),' ',substr(today,4,2),', ', |
put edit(substr(today,1,3),' ',substr(today,4,2),', ', |
||
substr(today,6,4))(A); |
substr(today,6,4))(A); |
||
end;</ |
end;</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>2013-11-02 |
<pre>2013-11-02 |
||
Line 2,628: | Line 2,937: | ||
===Version 2=== |
===Version 2=== |
||
< |
<syntaxhighlight lang="pl/i"> df: proc Options(Main); |
||
declare day_of_week(7) character(9) varying initial( |
declare day_of_week(7) character(9) varying initial( |
||
'Sunday','Monday','Tuesday','Wednesday', |
'Sunday','Monday','Tuesday','Wednesday', |
||
Line 2,643: | Line 2,952: | ||
put edit(month(substr(today,1,2)),' ',substr(today,3,2),', ', |
put edit(month(substr(today,1,2)),' ',substr(today,3,2),', ', |
||
substr(today,5,4))(A); |
substr(today,5,4))(A); |
||
End;</ |
End;</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>2013-11-02 |
<pre>2013-11-02 |
||
Line 2,649: | Line 2,958: | ||
=={{header|PowerShell}}== |
=={{header|PowerShell}}== |
||
< |
<syntaxhighlight lang="powershell">"{0:yyyy-MM-dd}" -f (Get-Date) |
||
"{0:dddd, MMMM d, yyyy}" -f (Get-Date) |
"{0:dddd, MMMM d, yyyy}" -f (Get-Date) |
||
# or |
# or |
||
(Get-Date).ToString("yyyy-MM-dd") |
(Get-Date).ToString("yyyy-MM-dd") |
||
(Get-Date).ToString("dddd, MMMM d, yyyy")</ |
(Get-Date).ToString("dddd, MMMM d, yyyy")</syntaxhighlight> |
||
''Note:'' The names of months and days follow the currently set locale but otherwise the format is unchanged. |
''Note:'' The names of months and days follow the currently set locale but otherwise the format is unchanged. |
||
Line 2,660: | Line 2,969: | ||
{{works with|SWI-Prolog|6}} |
{{works with|SWI-Prolog|6}} |
||
< |
<syntaxhighlight lang="prolog"> |
||
display_date :- |
display_date :- |
||
get_time(Time), |
get_time(Time), |
||
Line 2,666: | Line 2,975: | ||
format_time(atom(Long), '%A, %B %d, %Y', Time), |
format_time(atom(Long), '%A, %B %d, %Y', Time), |
||
format('~w~n~w~n', [Short, Long]). |
format('~w~n~w~n', [Short, Long]). |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|PureBasic}}== |
=={{header|PureBasic}}== |
||
{{works with|PureBasic|4.41}} |
{{works with|PureBasic|4.41}} |
||
< |
<syntaxhighlight lang="purebasic">;Declare Procedures |
||
Declare.s MonthInText() |
Declare.s MonthInText() |
||
Declare.s DayInText() |
Declare.s DayInText() |
||
Line 2,710: | Line 3,019: | ||
EndSelect |
EndSelect |
||
ProcedureReturn m$ |
ProcedureReturn m$ |
||
EndProcedure</ |
EndProcedure</syntaxhighlight> |
||
=={{header|Python}}== |
=={{header|Python}}== |
||
Formatting rules: http://docs.python.org/lib/module-time.html (strftime) |
Formatting rules: http://docs.python.org/lib/module-time.html (strftime) |
||
< |
<syntaxhighlight lang="python">import datetime |
||
today = datetime.date.today() |
today = datetime.date.today() |
||
# The first requested format is a method of datetime objects: |
|||
# This one is built in: |
|||
today.isoformat() |
|||
# For full flexibility, use the strftime formatting codes from the link above: |
|||
# Or use a format string for full flexibility: |
|||
today.strftime("%A, %B %d, %Y") |
|||
# This mechanism is integrated into the general string formatting system. |
|||
# You can do this with positional arguments referenced by number |
|||
"The date is {0:%A, %B %d, %Y}".format(d) |
|||
# Or keyword arguments referenced by name |
|||
"The date is {date:%A, %B %d, %Y}".format(date=d) |
|||
# Since Python 3.6, f-strings allow the value to be inserted inline |
|||
f"The date is {d:%A, %B %d, %Y}" |
|||
</syntaxhighlight> |
|||
=={{header|R}}== |
=={{header|R}}== |
||
strftime is short for "string format time". |
strftime is short for "string format time". |
||
< |
<syntaxhighlight lang="rsplus">now <- Sys.time() |
||
strftime(now, "%Y-%m-%d") |
strftime(now, "%Y-%m-%d") |
||
strftime(now, "%A, %B %d, %Y")</ |
strftime(now, "%A, %B %d, %Y")</syntaxhighlight> |
||
=={{header|Racket}}== |
=={{header|Racket}}== |
||
Line 2,740: | Line 3,057: | ||
See: http://srfi.schemers.org/srfi-19/srfi-19.html |
See: http://srfi.schemers.org/srfi-19/srfi-19.html |
||
< |
<syntaxhighlight lang="racket">#lang racket |
||
(require srfi/19) |
(require srfi/19) |
||
Line 2,752: | Line 3,069: | ||
(displayln (date->string (current-date) "~A, ~B ~d, ~Y")) |
(displayln (date->string (current-date) "~A, ~B ~d, ~Y")) |
||
;;; ~e is space padded day of month: |
;;; ~e is space padded day of month: |
||
(displayln (date->string (current-date) "~A, ~B ~e, ~Y"))</ |
(displayln (date->string (current-date) "~A, ~B ~e, ~Y"))</syntaxhighlight> |
||
both ~d and ~e satisfy the format required, since the "10" part of that date is 2-digit |
both ~d and ~e satisfy the format required, since the "10" part of that date is 2-digit |
||
Line 2,763: | Line 3,080: | ||
(formerly Perl 6) |
(formerly Perl 6) |
||
{{libheader|DateTime::Format}} |
{{libheader|DateTime::Format}} |
||
<lang |
<syntaxhighlight lang="raku" line>use DateTime::Format; |
||
my $dt = DateTime.now; |
my $dt = DateTime.now; |
||
say strftime('%Y-%m-%d', $dt); |
say strftime('%Y-%m-%d', $dt); |
||
say strftime('%A, %B %d, %Y', $dt);</ |
say strftime('%A, %B %d, %Y', $dt);</syntaxhighlight> |
||
The built-in Date and DateTime classes both offer support for the ISO format: |
The built-in Date and DateTime classes both offer support for the ISO format: |
||
<lang |
<syntaxhighlight lang="raku" line>my $d = Date.today; |
||
say $d.yyyy-mm-dd;</ |
say $d.yyyy-mm-dd;</syntaxhighlight> |
||
They don't include the longer format specified in the task, but you can always roll your own formatter instead of importing the library: |
They don't include the longer format specified in the task, but you can always roll your own formatter instead of importing the library: |
||
<lang |
<syntaxhighlight lang="raku" line>my @months = <January February March April May June July |
||
August September October November December>; |
August September October November December>; |
||
my @days = <Monday Tuesday Wednesday Thursday Friday Saturday Sunday>; |
my @days = <Monday Tuesday Wednesday Thursday Friday Saturday Sunday>; |
||
Line 2,784: | Line 3,101: | ||
say $d.yyyy-mm-dd; # still works |
say $d.yyyy-mm-dd; # still works |
||
say $d; # uses our formatter sub</ |
say $d; # uses our formatter sub</syntaxhighlight> |
||
=={{header|Raven}}== |
=={{header|Raven}}== |
||
<lang |
<syntaxhighlight lang="raven">time int as today</syntaxhighlight> |
||
Short form: |
Short form: |
||
< |
<syntaxhighlight lang="raven">today '%Y-%m-%d' date</syntaxhighlight> |
||
Long form: |
Long form: |
||
< |
<syntaxhighlight lang="raven">today '%A, %B %d, %Y' date</syntaxhighlight> |
||
=={{header|REBOL}}== |
=={{header|REBOL}}== |
||
< |
<syntaxhighlight lang="rebol">REBOL [ |
||
Title: "Date Formatting" |
Title: "Date Formatting" |
||
URL: http://rosettacode.org/wiki/Date_format |
URL: http://rosettacode.org/wiki/Date_format |
||
Line 2,820: | Line 3,137: | ||
pick system/locale/months now/month " " |
pick system/locale/months now/month " " |
||
now/day ", " now/year |
now/day ", " now/year |
||
]</ |
]</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 2,827: | Line 3,144: | ||
Sunday, December 6, 2009</pre> |
Sunday, December 6, 2009</pre> |
||
=={{header|RED}}== |
=={{header|RED}}== |
||
<syntaxhighlight lang="red"> |
|||
<lang RED> |
|||
Red [] |
Red [] |
||
;; zeropad |
;; zeropad |
||
Line 2,836: | Line 3,153: | ||
print rejoin [d/year "-" f2n d/month "-" f2n d/day] |
print rejoin [d/year "-" f2n d/month "-" f2n d/day] |
||
print rejoin [system/locale/days/(d/weekday) ", " system/locale/months/(d/month) " " f2n d/day ", " d/year] |
print rejoin [system/locale/days/(d/weekday) ", " system/locale/months/(d/month) " " f2n d/day ", " d/year] |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}}<pre>2020-03-25 |
{{out}}<pre>2020-03-25 |
||
Wednesday, March 25, 2020 |
Wednesday, March 25, 2020 |
||
Line 2,844: | Line 3,161: | ||
<br>It's up to the programmer to choose whatever version of the '''date''' BIF that best serves the purpose. |
<br>It's up to the programmer to choose whatever version of the '''date''' BIF that best serves the purpose. |
||
===idiomatic version=== |
===idiomatic version=== |
||
< |
<syntaxhighlight lang="rexx">/*REXX pgm shows current date: yyyy-mm-dd & Dayofweek, Month dd, yyyy*/ |
||
x = date('S') /*get current date as yyyymmdd */ |
x = date('S') /*get current date as yyyymmdd */ |
||
yyyy = left(x,4) /*pick off year (4 digs).*/ |
yyyy = left(x,4) /*pick off year (4 digs).*/ |
||
Line 2,855: | Line 3,172: | ||
zdd = dd+0 /*remove leading zero from DD */ |
zdd = dd+0 /*remove leading zero from DD */ |
||
say weekday',' month zdd"," yyyy /*format date as: Month dd, yyyy*/ |
say weekday',' month zdd"," yyyy /*format date as: Month dd, yyyy*/ |
||
/*stick a fork in it, we're done.*/</ |
/*stick a fork in it, we're done.*/</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 2,863: | Line 3,180: | ||
===compact version=== |
===compact version=== |
||
< |
<syntaxhighlight lang="rexx">/*REXX pgm shows current date: yyyy-mm-dd & Dayofweek, Month dd, yyyy*/ |
||
/* ╔══════════════════════════════════════════════════════════════════╗ |
/* ╔══════════════════════════════════════════════════════════════════╗ |
||
║ function returns a specific example ║ |
║ function returns a specific example ║ |
||
Line 2,890: | Line 3,207: | ||
say date('W')"," date('M') word(date(), 1)"," yyyy |
say date('W')"," date('M') word(date(), 1)"," yyyy |
||
/* [↑] dayofweek Month dd, yyyy*/ |
/* [↑] dayofweek Month dd, yyyy*/ |
||
/*stick a fork in it, we're done.*/</ |
/*stick a fork in it, we're done.*/</syntaxhighlight> |
||
'''output''' would be the same as the 1<sup>st</sup> version. |
'''output''' would be the same as the 1<sup>st</sup> version. |
||
===modern version=== |
===modern version=== |
||
This version can be used with those REXXes that support the '''I''' (ISO) parameter for the '''date''' BIF. |
This version can be used with those REXXes that support the '''I''' (ISO) parameter for the '''date''' BIF. |
||
< |
<syntaxhighlight lang="rexx">/*REXX pgm shows current date: yyyy-mm-dd & Dayofweek, Month dd, yyyy*/ |
||
say date('I') /*yyyy-mm-dd with leading zeroes.*/ |
say date('I') /*yyyy-mm-dd with leading zeroes.*/ |
||
Line 2,901: | Line 3,218: | ||
/* [↑] dayofweek Month dd, yyyy*/ |
/* [↑] dayofweek Month dd, yyyy*/ |
||
/*stick a fork in it, we're done.*/ |
/*stick a fork in it, we're done.*/ |
||
</syntaxhighlight> |
|||
</lang> |
|||
'''output''' would be the same as the 1<sup>st</sup> version. |
'''output''' would be the same as the 1<sup>st</sup> version. |
||
<br><br> |
<br><br> |
||
=={{header|Ring}}== |
=={{header|Ring}}== |
||
<syntaxhighlight lang="c"> |
|||
<lang ring> |
|||
dateStr = date() |
dateStr = date() |
||
date1 = timelist()[19] + "-" + timelist()[10] + "-" + timelist()[6] |
date1 = timelist()[19] + "-" + timelist()[10] + "-" + timelist()[6] |
||
Line 2,913: | Line 3,230: | ||
? date1 |
? date1 |
||
? date2 |
? date2 |
||
</lang> |
|||
/* |
|||
timelist() ---> List contains the time and date information. |
|||
Index Value |
|||
---------------------------- |
|||
1 - abbreviated weekday name |
|||
2 - full weekday name |
|||
3 - abbreviated month name |
|||
4 - full month name |
|||
5 - Date & Time |
|||
6 - Day of the month |
|||
7 - Hour (24) |
|||
8 - Hour (12) |
|||
9 - Day of the year |
|||
10 - Month of the year |
|||
11 - Minutes after hour |
|||
12 - AM or PM |
|||
13 - Seconds after the hour |
|||
14 - Week of the year (sun-sat) |
|||
15 - day of the week |
|||
16 - date |
|||
17 - time |
|||
18 - year of the century |
|||
19 - year |
|||
20 - time zone |
|||
21 - percent sign |
|||
*/ |
|||
</syntaxhighlight> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 2,919: | Line 3,264: | ||
2020-07-19 |
2020-07-19 |
||
Sunday, July 19, 2020 |
Sunday, July 19, 2020 |
||
</pre> |
|||
=={{header|RPL}}== |
|||
RPL can return the date as a floating point number (format dd.mmyyyy) and can convert it (along with the time) as a string (format "DAY dd.mm.yy hh.mm.ss") |
|||
To solve the task, some formatting is then needed. |
|||
{{works with|HP|48}} |
|||
≪ DATE DUP 1000000 * 10000 MOD "-" + |
|||
OVER FP 100 * IP + "-" + |
|||
SWAP IP + |
|||
≫ '<span style="color:blue">DTSHORT</span>' STO |
|||
≪ { "Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday" "Sunday" } |
|||
{ "MON" "TUE" "WED" "THU" "FRI" "SAT" "SUN" } |
|||
DATE TIME TSTR 1 3 SUB POS GET ", " + |
|||
{ "January" "February" "March" "April" "May" "June" "July" "August" "September" "October" "November" "December"} |
|||
DATE FP 100 * IP GET + " " + |
|||
OVER IP + ", " + |
|||
DATE 1000000 * 10000 MOD + |
|||
≫ '<span style="color:blue">DTLONG</span>' STO |
|||
{{out}} |
|||
<pre> |
|||
2: "2023-8-17" |
|||
1: "Thursday, August 17, 2023" |
|||
</pre> |
</pre> |
||
Line 2,924: | Line 3,292: | ||
Formatting rules: [//www.ruby-doc.org/core/Time.html#method-i-strftime Time#strftime] |
Formatting rules: [//www.ruby-doc.org/core/Time.html#method-i-strftime Time#strftime] |
||
< |
<syntaxhighlight lang="ruby">puts Time.now |
||
puts Time.now.strftime('%Y-%m-%d') |
puts Time.now.strftime('%Y-%m-%d') |
||
puts Time.now.strftime('%F') # same as %Y-%m-%d (ISO 8601 date formats) |
puts Time.now.strftime('%F') # same as %Y-%m-%d (ISO 8601 date formats) |
||
puts Time.now.strftime('%A, %B %d, %Y')</ |
puts Time.now.strftime('%A, %B %d, %Y')</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 2,937: | Line 3,305: | ||
=={{header|Run BASIC}}== |
=={{header|Run BASIC}}== |
||
< |
<syntaxhighlight lang="runbasic">'Display the current date in the formats of "2007-11-10" and "Sunday, November 10, 2007". |
||
print date$("yyyy-mm-dd") |
print date$("yyyy-mm-dd") |
||
print date$("dddd");", "; 'return full day of the week (eg. Wednesday |
print date$("dddd");", "; 'return full day of the week (eg. Wednesday |
||
print date$("mmmm");" "; 'return full month name (eg. March) |
print date$("mmmm");" "; 'return full month name (eg. March) |
||
print date$("dd, yyyy") 'return day, year</ |
print date$("dd, yyyy") 'return day, year</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 2,950: | Line 3,318: | ||
=={{header|Rust}}== |
=={{header|Rust}}== |
||
Using <code>chrono 0.4.6</code> |
Using <code>chrono 0.4.6</code> |
||
< |
<syntaxhighlight lang="rust">fn main() { |
||
let now = chrono::Utc::now(); |
let now = chrono::Utc::now(); |
||
println!("{}", now.format("%Y-%m-%d")); |
println!("{}", now.format("%Y-%m-%d")); |
||
println!("{}", now.format("%A, %B %d, %Y")); |
println!("{}", now.format("%A, %B %d, %Y")); |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Scala}}== |
=={{header|Scala}}== |
||
<lang |
<syntaxhighlight lang="scala"> |
||
import java.util.Date |
|||
val now=new Date() |
|||
println("%tF".format(now)) |
println("%tF".format(now)) |
||
println("%1$tA, %1$tB %1$td, %1$tY".format(now))</ |
println("%1$tA, %1$tB %1$td, %1$tY".format(now))</syntaxhighlight> |
||
{{out}} |
|||
<pre> |
|||
2023-04-17 |
|||
Monday, April 17, 2023 |
|||
</pre> |
|||
=={{header|Scheme}}== |
=={{header|Scheme}}== |
||
Line 2,965: | Line 3,342: | ||
{{works with|Guile|2.0.13}} |
{{works with|Guile|2.0.13}} |
||
< |
<syntaxhighlight lang="scheme">(define short-date |
||
(lambda (lt) |
(lambda (lt) |
||
(strftime "%Y-%m-%d" (localtime lt)))) |
(strftime "%Y-%m-%d" (localtime lt)))) |
||
Line 2,982: | Line 3,359: | ||
(display (long-date dt))(newline)))) |
(display (long-date dt))(newline)))) |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Seed7}}== |
=={{header|Seed7}}== |
||
< |
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i"; |
||
include "time.s7i"; |
include "time.s7i"; |
||
Line 2,998: | Line 3,375: | ||
writeln(strDate(now)); |
writeln(strDate(now)); |
||
writeln(days[dayOfWeek(now)] <& ", " <& months[now.month] <& " " <& now.day <& ", " <& now.year); |
writeln(days[dayOfWeek(now)] <& ", " <& months[now.month] <& " " <& now.day <& ", " <& now.year); |
||
end func;</ |
end func;</syntaxhighlight> |
||
=={{header|SenseTalk}}== |
=={{header|SenseTalk}}== |
||
< |
<syntaxhighlight lang="sensetalk"> |
||
put formattedTime( "[year]-[month]-[day]", the date) |
put formattedTime( "[year]-[month]-[day]", the date) |
||
put formattedTime( "[weekday], [month name] [day], [year]", the date) |
put formattedTime( "[weekday], [month name] [day], [year]", the date) |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre>2019-12-18 |
<pre>2019-12-18 |
||
Line 3,011: | Line 3,388: | ||
=={{header|Shiny}}== |
=={{header|Shiny}}== |
||
< |
<syntaxhighlight lang="shiny">say time.format 'Y-m-d' time.now |
||
say time.format 'l, F j, Y' time.now</ |
say time.format 'l, F j, Y' time.now</syntaxhighlight> |
||
=={{header|Sidef}}== |
=={{header|Sidef}}== |
||
< |
<syntaxhighlight lang="ruby">var time = Time.local; |
||
say time.ctime; |
say time.ctime; |
||
say time.strftime("%Y-%m-%d"); |
say time.strftime("%Y-%m-%d"); |
||
say time.strftime("%A, %B %d, %Y");</ |
say time.strftime("%A, %B %d, %Y");</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 3,029: | Line 3,406: | ||
In Smalltalk, one sends a <tt>printFormat</tt> message to a Date object with year, month, and day. For other date strings, one must construct the date string from the parts of a Date object. Of course, you'd probably want to make a method for doing so. |
In Smalltalk, one sends a <tt>printFormat</tt> message to a Date object with year, month, and day. For other date strings, one must construct the date string from the parts of a Date object. Of course, you'd probably want to make a method for doing so. |
||
< |
<syntaxhighlight lang="smalltalk">| d | |
||
d := Date today. |
d := Date today. |
||
d printFormat: #(3 2 1 $- 1 1 2). |
d printFormat: #(3 2 1 $- 1 1 2). |
||
(d weekday asString), ', ', (d monthName), ' ', (d dayOfMonth asString), ', ', (d year asString)</ |
(d weekday asString), ', ', (d monthName), ' ', (d dayOfMonth asString), ', ', (d year asString)</syntaxhighlight> |
||
{{works with|Smalltalk/X}} |
{{works with|Smalltalk/X}} |
||
< |
<syntaxhighlight lang="smalltalk">d := Date today. |
||
d printOn:Stdout format:'%y-%m-%d'. Stdout cr. |
d printOn:Stdout format:'%y-%m-%d'. Stdout cr. |
||
d printOn:Stdout format:'%(DayName), %(MonthName) %d, %y' language:#en. Stdout cr. |
d printOn:Stdout format:'%(DayName), %(MonthName) %d, %y' language:#en. Stdout cr. |
||
d printOn:Stdout format:'%(DayName), %(MonthName) %d, %y' language:#de. Stdout cr. |
d printOn:Stdout format:'%(DayName), %(MonthName) %d, %y' language:#de. Stdout cr. |
||
d printOn:Stdout format:'%(DayName), %(MonthName) %d, %y' language:#fr. Stdout cr.</ |
d printOn:Stdout format:'%(DayName), %(MonthName) %d, %y' language:#fr. Stdout cr.</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>2020-12-17 |
<pre>2020-12-17 |
||
Line 3,044: | Line 3,421: | ||
Donnerstag, Dezember 17, 2020 |
Donnerstag, Dezember 17, 2020 |
||
Vendredi, Décembre 17, 2020</pre> |
Vendredi, Décembre 17, 2020</pre> |
||
=={{header|SparForte}}== |
|||
As a structured script. Does not use l10n package. |
|||
<syntaxhighlight lang="ada">#!/usr/local/bin/spar |
|||
pragma annotate( summary, "dateformat") |
|||
@( description, "Display the current date in the formats of '2007-11-10' " ) |
|||
@( description, "and 'Sunday, November 10, 2007'." ) |
|||
@( see_also, "http://rosettacode.org/wiki/Date_format" ) |
|||
@( "Ken O. Burtch" ); |
|||
pragma license( unrestricted ); |
|||
pragma restriction( no_external_commands ); |
|||
procedure dateformat is |
|||
function Month_Image (Month : calendar.month_number) return string is |
|||
begin |
|||
case Month is |
|||
when 1 => return "January"; |
|||
when 2 => return "February"; |
|||
when 3 => return "March"; |
|||
when 4 => return "April"; |
|||
when 5 => return "May"; |
|||
when 6 => return "June"; |
|||
when 7 => return "July"; |
|||
when 8 => return "August"; |
|||
when 9 => return "September"; |
|||
when 10 => return "October"; |
|||
when 11 => return "November"; |
|||
when others => return "December"; |
|||
end case; |
|||
end Month_Image; |
|||
function Day_Image (Day : integer) return string is |
|||
begin |
|||
case Day is |
|||
when 0 => return "Monday"; |
|||
when 1 => return "Tuesday"; |
|||
when 2 => return "Wednesday"; |
|||
when 3 => return "Thursday"; |
|||
when 4 => return "Friday"; |
|||
when 5 => return "Saturday"; |
|||
when others => return "Sunday"; |
|||
end case; |
|||
end Day_Image; |
|||
Today : constant calendar.time := calendar.clock; |
|||
begin |
|||
--put_line( |
|||
--Put_Line (Image (Today) (1..10)); |
|||
put( calendar.year( Today ), "9999" ) @( "-" ) |
|||
@( calendar.month( Today ), "99" ) @( "-" ) |
|||
@( calendar.day( Today ), "99" ); |
|||
new_line; |
|||
put_line( |
|||
Day_Image( calendar.day_of_week( Today ) ) & ", " & |
|||
Month_Image( calendar.month( Today ) ) & |
|||
strings.image( calendar.day( Today ) ) & "," & |
|||
strings.image( calendar.year( Today ) ) ); |
|||
end dateformat;</syntaxhighlight> |
|||
=={{header|SQL}}== |
=={{header|SQL}}== |
||
{{works with|Oracle}} |
{{works with|Oracle}} |
||
< |
<syntaxhighlight lang="sql"> |
||
select to_char(sysdate,'YYYY-MM-DD') date_fmt_1 from dual; |
select to_char(sysdate,'YYYY-MM-DD') date_fmt_1 from dual; |
||
select to_char(sysdate,'fmDay, Month DD, YYYY') date_fmt_2 from dual; |
select to_char(sysdate,'fmDay, Month DD, YYYY') date_fmt_2 from dual; |
||
</syntaxhighlight> |
|||
</lang> |
|||
<pre> |
<pre> |
||
Line 3,068: | Line 3,504: | ||
Formatting rules: http://www.standardml.org/Basis/date.html#SIG:DATE.fmt:VAL |
Formatting rules: http://www.standardml.org/Basis/date.html#SIG:DATE.fmt:VAL |
||
< |
<syntaxhighlight lang="sml">print (Date.fmt "%Y-%m-%d" (Date.fromTimeLocal (Time.now ())) ^ "\n"); |
||
print (Date.fmt "%A, %B %d, %Y" (Date.fromTimeLocal (Time.now ())) ^ "\n");</ |
print (Date.fmt "%A, %B %d, %Y" (Date.fromTimeLocal (Time.now ())) ^ "\n");</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 3,080: | Line 3,516: | ||
Stata has many ways to format dates, see [https://www.stata.com/help.cgi?Datetime_display_formats Datetime display formats] in the documentation. |
Stata has many ways to format dates, see [https://www.stata.com/help.cgi?Datetime_display_formats Datetime display formats] in the documentation. |
||
< |
<syntaxhighlight lang="stata">display %tdCCYY-NN-DD td($S_DATE) |
||
display %tdDayname,_Month_dd,_CCYY td($S_DATE)</ |
display %tdDayname,_Month_dd,_CCYY td($S_DATE)</syntaxhighlight> |
||
=={{header|Suneido}}== |
=={{header|Suneido}}== |
||
< |
<syntaxhighlight lang="suneido">Date().Format('yyyy-MM-dd') --> "2010-03-16" |
||
Date().LongDate() --> "Tuesday, March 16, 2010" </ |
Date().LongDate() --> "Tuesday, March 16, 2010" </syntaxhighlight> |
||
=={{header|Swift}}== |
=={{header|Swift}}== |
||
< |
<syntaxhighlight lang="swift">import Foundation |
||
extension String { |
extension String { |
||
func toStandardDateWithDateFormat(format: String) -> String { |
func toStandardDateWithDateFormat(format: String) -> String { |
||
Line 3,098: | Line 3,534: | ||
} |
} |
||
let date = "2015-08-28".toStandardDateWithDateFormat("yyyy-MM-dd")</ |
let date = "2015-08-28".toStandardDateWithDateFormat("yyyy-MM-dd")</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 3,106: | Line 3,542: | ||
=={{header|Tcl}}== |
=={{header|Tcl}}== |
||
< |
<syntaxhighlight lang="tcl">set now [clock seconds] |
||
puts [clock format $now -format "%Y-%m-%d"] |
puts [clock format $now -format "%Y-%m-%d"] |
||
puts [clock format $now -format "%A, %B %d, %Y"]</ |
puts [clock format $now -format "%A, %B %d, %Y"]</syntaxhighlight> |
||
=={{header|Terraform}}== |
=={{header|Terraform}}== |
||
< |
<syntaxhighlight lang="terraform">locals { |
||
today = timestamp() |
today = timestamp() |
||
} |
} |
||
Line 3,121: | Line 3,557: | ||
output "us-long" { |
output "us-long" { |
||
value = formatdate("EEEE, MMMM D, YYYY", local.today) |
value = formatdate("EEEE, MMMM D, YYYY", local.today) |
||
}</ |
}</syntaxhighlight> |
||
{{Out}} |
{{Out}} |
||
Line 3,132: | Line 3,568: | ||
=={{header|TUSCRIPT}}== |
=={{header|TUSCRIPT}}== |
||
< |
<syntaxhighlight lang="tuscript"> |
||
$$ MODE TUSCRIPT |
$$ MODE TUSCRIPT |
||
SET dayofweek = DATE (today,day,month,year,number) |
SET dayofweek = DATE (today,day,month,year,number) |
||
Line 3,160: | Line 3,596: | ||
PRINT format1 |
PRINT format1 |
||
PRINT format2 |
PRINT format2 |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 3,168: | Line 3,604: | ||
=={{header|UNIX Shell}}== |
=={{header|UNIX Shell}}== |
||
< |
<syntaxhighlight lang="bash">date +"%Y-%m-%d" |
||
date +"%A, %B %d, %Y"</ |
date +"%A, %B %d, %Y"</syntaxhighlight> |
||
On a new enough system <code>%F</code> is equivalent to <code>%Y-%m-%d</code> |
On a new enough system <code>%F</code> is equivalent to <code>%Y-%m-%d</code> |
||
< |
<syntaxhighlight lang="bash">date +"%F"</syntaxhighlight> |
||
<!-- ENHANCE-ME: what is new enough for %F ? For example it doesn't appear in these bits of POSIX, |
<!-- ENHANCE-ME: what is new enough for %F ? For example it doesn't appear in these bits of POSIX, |
||
Line 3,182: | Line 3,618: | ||
{{works with|Cygnus/X Ursa}} |
{{works with|Cygnus/X Ursa}} |
||
Cygnus/X Ursa can import and call Java classes. |
Cygnus/X Ursa can import and call Java classes. |
||
< |
<syntaxhighlight lang="ursa">cygnus/x ursa v0.78 (default, release 0) |
||
[Oracle Corporation JVM 1.8.0_51 on Mac OS X 10.10.5 x86_64] |
[Oracle Corporation JVM 1.8.0_51 on Mac OS X 10.10.5 x86_64] |
||
> import "java.util.Date" |
> import "java.util.Date" |
||
Line 3,194: | Line 3,630: | ||
> out (sdf.format d) endl console |
> out (sdf.format d) endl console |
||
Saturday, July 23, 2016 |
Saturday, July 23, 2016 |
||
> _</ |
> _</syntaxhighlight> |
||
=={{header|Ursala}}== |
=={{header|Ursala}}== |
||
The method is to transform a date in standard format returned by the library function, now. |
The method is to transform a date in standard format returned by the library function, now. |
||
< |
<syntaxhighlight lang="ursala">#import std |
||
#import cli |
#import cli |
||
Line 3,214: | Line 3,650: | ||
#show+ |
#show+ |
||
main = <.text_form,numeric_form> now0</ |
main = <.text_form,numeric_form> now0</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>Wednesday, June 24, 2009 |
<pre>Wednesday, June 24, 2009 |
||
Line 3,221: | Line 3,657: | ||
=={{header|VB-DOS|PDS 7.1 BASIC}}== |
=={{header|VB-DOS|PDS 7.1 BASIC}}== |
||
{{works with|Visual Basic for DOS and PDS 7.1}} |
{{works with|Visual Basic for DOS and PDS 7.1}} |
||
<syntaxhighlight lang="vb"> |
|||
<lang vb> |
|||
OPTION EXPLICIT |
OPTION EXPLICIT |
||
Line 3,260: | Line 3,696: | ||
END |
END |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|VBA}}== |
=={{header|VBA}}== |
||
< |
<syntaxhighlight lang="vba">Function DateFormats() |
||
Debug.Print Format(Date, "yyyy-mm-dd") |
Debug.Print Format(Date, "yyyy-mm-dd") |
||
Debug.Print Format(Date, "dddd, mmmm dd yyyy") |
Debug.Print Format(Date, "dddd, mmmm dd yyyy") |
||
End Function</ |
End Function</syntaxhighlight> |
||
=={{header|VBScript}}== |
=={{header|VBScript}}== |
||
<syntaxhighlight lang="vb"> |
|||
<lang vb> |
|||
'YYYY-MM-DD format |
'YYYY-MM-DD format |
||
WScript.StdOut.WriteLine Year(Date) & "-" & Right("0" & Month(Date),2) & "-" & Right("0" & Day(Date),2) |
WScript.StdOut.WriteLine Year(Date) & "-" & Right("0" & Month(Date),2) & "-" & Right("0" & Day(Date),2) |
||
Line 3,276: | Line 3,712: | ||
'Weekday_Name, Month_Name DD, YYYY format |
'Weekday_Name, Month_Name DD, YYYY format |
||
WScript.StdOut.WriteLine FormatDateTime(Now,1) |
WScript.StdOut.WriteLine FormatDateTime(Now,1) |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{Out}} |
{{Out}} |
||
Line 3,287: | Line 3,723: | ||
Display current date in format "2007-11-10": |
Display current date in format "2007-11-10": |
||
< |
<syntaxhighlight lang="vedit">Date(REVERSE+NOMSG+VALUE, '-')</syntaxhighlight> |
||
Display current date in format "Sunday, November 10, 2007" (Requires VEDIT 6.2): |
Display current date in format "Sunday, November 10, 2007" (Requires VEDIT 6.2): |
||
< |
<syntaxhighlight lang="vedit">// Get todays date into #1, #2, #3 and #7 |
||
#1 = Date_Day |
#1 = Date_Day |
||
#2 = Date_Month |
#2 = Date_Month |
||
Line 3,320: | Line 3,756: | ||
// Display the date string |
// Display the date string |
||
RT(1) M(", ") RT(2) M(" ") NT(#1, LEFT+NOCR) M(",") NT(#3)</ |
RT(1) M(", ") RT(2) M(" ") NT(#1, LEFT+NOCR) M(",") NT(#3)</syntaxhighlight> |
||
To insert the date string into edit buffer instead of displaying it, replace the last line with this: |
To insert the date string into edit buffer instead of displaying it, replace the last line with this: |
||
< |
<syntaxhighlight lang="vedit">RI(1) IT(", ") RI(2) IT(" ") NI(#1, LEFT+NOCR) IT(",") NI(#3)</syntaxhighlight> |
||
=={{header|Vim Script}}== |
|||
See `:help strftime` - this function uses the C strftime() arguments' format. |
|||
<syntaxhighlight lang="vim"> |
|||
echo strftime("%Y-%m-%d") |
|||
echo strftime("%A, %B %d, %Y") |
|||
</syntaxhighlight> |
|||
=={{header|V (Vlang)}}== |
|||
<syntaxhighlight lang="v (vlang)">import time |
|||
fn main() { |
|||
println(time.now().custom_format("YYYY-MM-DD")) |
|||
println(time.now().custom_format("dddd, MMMM D, YYYY")) |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2011-12-02 |
|||
Friday, December 2, 2011 |
|||
</pre> |
|||
=={{header|Wren}}== |
=={{header|Wren}}== |
||
{{libheader|Wren-date}} |
{{libheader|Wren-date}} |
||
Unless it is embedded in a host application, Wren currently has no direct way to obtain the current date. We therefore assume this is passed in by the user as a command line parameter. |
Unless it is embedded in a host application, Wren currently has no direct way to obtain the current date. We therefore assume this is passed in by the user as a command line parameter. |
||
< |
<syntaxhighlight lang="wren">import "os" for Process |
||
import "/date" for Date |
import "./date" for Date |
||
var args = Process.arguments |
var args = Process.arguments |
||
Line 3,338: | Line 3,795: | ||
var current = Date.parse(args[0]) |
var current = Date.parse(args[0]) |
||
System.print(current.format(Date.isoDate)) |
System.print(current.format(Date.isoDate)) |
||
System.print(current.format("dddd|, |mmmm| |d|, |yyyy"))</ |
System.print(current.format("dddd|, |mmmm| |d|, |yyyy"))</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 3,348: | Line 3,805: | ||
=={{header|XPL0}}== |
=={{header|XPL0}}== |
||
< |
<syntaxhighlight lang="xpl0">include c:\cxpl\codes; |
||
int CpuReg, Year, Month, Day, DName, MName, WDay; |
int CpuReg, Year, Month, Day, DName, MName, WDay; |
||
[CpuReg:= GetReg; \access CPU registers |
[CpuReg:= GetReg; \access CPU registers |
||
Line 3,366: | Line 3,823: | ||
Text(0, DName(WDay)); Text(0, ", "); Text(0, MName(Month)); Text(0, " "); |
Text(0, DName(WDay)); Text(0, ", "); Text(0, MName(Month)); Text(0, " "); |
||
IntOut(0, Day); Text(0, ", "); IntOut(0, Year); CrLf(0); |
IntOut(0, Day); Text(0, ", "); IntOut(0, Year); CrLf(0); |
||
]</ |
]</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 3,375: | Line 3,832: | ||
=={{header|Yabasic}}== |
=={{header|Yabasic}}== |
||
< |
<syntaxhighlight lang="yabasic">dim n$(1) |
||
n = token(date$, n$(), "-") |
n = token(date$, n$(), "-") |
||
Line 3,402: | Line 3,859: | ||
return month$(int(n/3) + 1) |
return month$(int(n/3) + 1) |
||
end sub</ |
end sub</syntaxhighlight> |
||
=={{header|zkl}}== |
=={{header|zkl}}== |
||
< |
<syntaxhighlight lang="zkl">"%d-%02d-%02d".fmt(Time.Clock.localTime.xplode()).println() |
||
//--> "2014-02-28" (ISO format)</ |
//--> "2014-02-28" (ISO format)</syntaxhighlight> |
||
Not quite but close. Even though localTime returns a 7 tuple (and xplode pushes all 7 as call args), fmt only eats what it needs. |
Not quite but close. Even though localTime returns a 7 tuple (and xplode pushes all 7 as call args), fmt only eats what it needs. |
||
< |
<syntaxhighlight lang="zkl">Time.Date.prettyDay(Time.Clock.localTime.xplode()) |
||
//--> "Friday, the 28th of February 2014"</ |
//--> "Friday, the 28th of February 2014"</syntaxhighlight> |
||
< |
<syntaxhighlight lang="zkl">y,m,d:=Time.Clock.localTime; D:=Time.Date; |
||
"%s, %s %d, %d".fmt(D.dayName(D.weekDay(y,m,d)), |
"%s, %s %d, %d".fmt(D.dayName(D.weekDay(y,m,d)), |
||
D.monthName(m), d,y) |
D.monthName(m), d,y) |
||
//-->"Friday, February 28, 2014"</ |
//-->"Friday, February 28, 2014"</syntaxhighlight> |
||
=={{header|zonnon}}== |
=={{header|zonnon}}== |
||
< |
<syntaxhighlight lang="zonnon"> |
||
module Main; |
module Main; |
||
import System; |
import System; |
||
Line 3,427: | Line 3,884: | ||
System.Console.WriteLine("{0}, {1}",now.DayOfWeek,now.ToString("MMMM dd, yyyy")); |
System.Console.WriteLine("{0}, {1}",now.DayOfWeek,now.ToString("MMMM dd, yyyy")); |
||
end Main. |
end Main. |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{Out}} |
{{Out}} |
||
<pre> |
<pre> |
Latest revision as of 11:14, 13 August 2024
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
Display the current date in the formats of:
- 2007-11-23 and
- Friday, November 23, 2007
11l
print(Time().format(‘YYYY-MM-DD’))
print(Time().strftime(‘%A, %B %e, %Y’))
68000 Assembly
This code only works on the arcade system, not the home consoles, because only the arcade system has a built-in system clock. which can be read using JSR $C0045C
. MAME uses your computer's date and time as the source for this data. The code below runs in-line and uses a few macros and labels, but they are mostly self-explanatory. The code required to set up the palettes and print characters to the screen has been omitted for brevity, but is fully implemented.
JSR SYS_READ_CALENDAR ;outputs calendar date to BIOS RAM
MOVE.B #'2',D0 ;a character in single or double quotes refers to its ascii equivalent.
JSR PrintChar
MOVE.B #'0',D0
JSR PrintChar
LEA BIOS_YEAR,A1
MOVE.B (A1)+,D0 ;stores last 2 digits of year into D0, in binary coded decimal
JSR UnpackNibbles8 ;separate the digits into high and low nibbles: D0 = 00020001
ADD.L #$00300030,D0 ;convert both numerals to their ascii equivalents.
SWAP D0 ;print the "2" first
JSR PrintChar
SWAP D0 ;then the "1"
JSR PrintChar
MOVE.B #'-',D0
JSR PrintChar
MOVE.B (A1)+,D0 ;get the month
JSR UnpackNibbles8
ADD.L #$00300030,D0
SWAP D0
JSR PrintChar
SWAP D0
JSR PrintChar
MOVE.B #'-',D0
JSR PrintChar
MOVE.B (A1)+,D0 ;get the day
JSR UnpackNibbles8
ADD.L #$00300030,D0
SWAP D0
JSR PrintChar
SWAP D0
JSR PrintChar
;now the date is printed.
;Now do it again only written out:
jsr NewLine
CLR.L D0 ;reset D0
MOVE.B (A1),D0 ;A1 happens to point to the weekday
LSL.W #2,D0 ;we are indexing into a table of longs
LEA Days_Lookup,A2
LEA (A2,D0),A2
MOVEA.L (A2),A3 ;dereference the pointer into A3, which the PrintString routine takes as an argument.
JSR PrintString
CLR.L D0
LEA BIOS_MONTH,A1 ;GET THE MONTH
MOVE.B (A1)+,D0
LSL.W #2,D0
LEA Months_Lookup,A2
LEA (A2,D0),A2
MOVEA.L (A2),A3
JSR PrintString
MOVE.B (A1),D0 ;GET THE DAY
JSR UnpackNibbles8
ADD.L #$00300030,D0
SWAP D0
JSR PrintChar
SWAP D0
JSR PrintChar
MOVE.B #',',D0
JSR PrintChar
MOVE.B #' ',D0
JSR PrintChar
MOVE.B #'2',D0
JSR PrintChar
MOVE.B #'0',D0
JSR PrintChar
LEA BIOS_YEAR,A1
MOVE.B (A1)+,D0 ;stores last 2 digits of year into D0, in binary coded decimal
JSR UnpackNibbles8 ;separate the digits into high and low nibbles: D0 = 00020001
ADD.L #$00300030,D0 ;convert both numerals to their ascii equivalents.
SWAP D0 ;print the "2" first
JSR PrintChar
SWAP D0 ;then the "1"
JSR PrintChar
forever:
bra forever ;trap the program counter
UnpackNibbles8:
; INPUT: D0 = THE VALUE YOU WISH TO UNPACK.
; HIGH NIBBLE IN HIGH WORD OF D0, LOW NIBBLE IN LOW WORD. SWAP D0 TO GET THE OTHER HALF.
pushWord D1
CLR.W D1
MOVE.B D0,D1
CLR.L D0
MOVE.B D1,D0 ;now D0 = D1 = $000000II, where I = input
AND.B #$F0,D0 ;chop off bottom nibble
LSR.B #4,D0 ;downshift top nibble into bottom nibble of the word
SWAP D0 ;store in high word
AND.B #$0F,D1 ;chop off bottom nibble
MOVE.B D1,D0 ;store in low word
popWord D1
rts
Output can be seen here, but is also reproduced below:
2021-09-19 Sunday, September 19, 2021
8th
d:new
"%Y-%M-%D" over d:format . cr
"%W, %N %D, %Y" over d:format . cr
bye
AArch64 Assembly
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program dateFormat64.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
szMessError: .asciz "Error detected !!!!. \n"
szMessResult: .asciz "Date : @/@/@ \n" // message result
szMessResult1: .asciz "Date day : @ @ @ @ \n" // message result
szJan: .asciz "Janvier"
szFev: .asciz "Fèvrier"
szMars: .asciz "Mars"
szAvril: .asciz "Avril"
szMai: .asciz "Mai"
szJuin: .asciz "Juin"
szJuil: .asciz "Juillet"
szAout: .asciz "Aout"
szSept: .asciz "Septembre"
szOct: .asciz "Octobre"
szNov: .asciz "Novembre"
szDec: .asciz "Décembre"
szLundi: .asciz "Lundi"
szMardi: .asciz "Mardi"
szMercredi: .asciz "Mercredi"
szJeudi: .asciz "Jeudi"
szVendredi: .asciz "Vendredi"
szSamedi: .asciz "Samedi"
szDimanche: .asciz "Dimanche"
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
tbMonthName: .quad szJan
.quad szFev
.quad szMars
.quad szAvril
.quad szMai
.quad szJuin
.quad szJuil
.quad szAout
.quad szSept
.quad szOct
.quad szNov
.quad szDec
tbDayName: .quad szLundi
.quad szMardi
.quad szMercredi
.quad szJeudi
.quad szVendredi
.quad szSamedi
.quad szDimanche
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
.align 4
stTVal: .skip timeval_end
stTZone: .skip timezone_end
sZoneConv: .skip 24
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: // entry of program
ldr x0,qAdrstTVal
ldr x1,qAdrstTZone
mov x8,#GETTIME
svc 0
cmp x0,#-1 // error ?
beq 99f
ldr x1,qAdrstTVal
ldr x0,[x1,#timeval_sec] // timestamp in second
bl dateFormatNum
ldr x0,[x1,#timeval_sec] // timestamp in second
bl dateFormatAlpha
ldr x0,qTStest1
bl dateFormatNum
ldr x0,qTStest1
bl dateFormatAlpha
ldr x0,qTStest2
bl dateFormatNum
ldr x0,qTStest2
bl dateFormatAlpha
ldr x0,qTStest3
bl dateFormatNum
ldr x0,qTStest3
bl dateFormatAlpha
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
qAdrszCarriageReturn: .quad szCarriageReturn
qAdrsZoneConv: .quad sZoneConv
qTStest1: .quad 1609508339 // 01/01/2021
qTStest2: .quad 1657805939 // 14/07/2022
qTStest3: .quad 1767221999 // 31/12/2025
/******************************************************************/
/* date format numeric */
/******************************************************************/
/* x0 contains the timestamp in seconds */
dateFormatNum:
stp x1,lr,[sp,-16]! // save registers
ldr x2,qSecJan2020
sub x0,x0,x2 // total secondes to 01/01/2020
mov x1,60
udiv x0,x0,x1 // divide secondes
udiv x0,x0,x1 // divide minutes
mov x1,#24
udiv x0,x0,x1 // divide hours
mov x11,x0
mov x1,#(365 * 4 + 1)
udiv x9,x0,x1
lsl x9,x9,#2 // multiply by 4 = year1
mov x1,#(365 * 4 + 1)
udiv x2,x11,x1
msub x10,x2,x1,x11
ldr x1,qAdrtbDayMonthYear
mov x2,#3
mov x3,#12
1:
mul x11,x3,x2
ldr x4,[x1,x11,lsl 3] // load days by year
cmp x10,x4
bge 2f
sub x2,x2,1
cbnz x2,1b
2: // x2 = year2
mov x5,11
mul x11,x3,x2
lsl x11,x11,3
add x11,x11,x1 // table address
3:
ldr x4,[x11,x5,lsl 3] // load days by month
cmp x10,x4
bge 4f
subs x5,x5,1
bne 3b
4: // x5 = month - 1
mul x11,x3,x2
add x11,x11,x5
ldr x1,qAdrtbDayMonthYear
ldr x3,[x1,x11,lsl 3]
sub x0,x10,x3
add x0,x0,1 // final compute day
ldr x1,qAdrsZoneConv
bl conversion10 // this function do not zero final
ldr x0,qAdrszMessResult
ldr x1,qAdrsZoneConv
bl strInsertAtCharInc // insert result at first // character
mov x3,x0
add x0,x5,1 // final compute month
cmp x0,12
sub x1,x0,12
csel x0,x1,x0,gt
ldr x1,qAdrsZoneConv
bl conversion10
mov x0,x3
ldr x1,qAdrsZoneConv
bl strInsertAtCharInc // insert result at next // character
mov x3,x0
ldr x11,qYearStart
add x0,x9,x11
add x0,x0,x2 // final compute year = 2020 + yeax1 + yeax2
ldr x1,qAdrsZoneConv
bl conversion10
mov x0,x3
ldr x1,qAdrsZoneConv
bl strInsertAtCharInc // insert result at next // character
bl affichageMess
100:
ldp x1,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
qAdrszMessResult: .quad szMessResult
/******************************************************************/
/* date format alphanumeric */
/******************************************************************/
/* x0 contains the timestamp in seconds */
dateFormatAlpha:
stp x1,lr,[sp,-16]! // save registers
ldr x2,qSecJan2020
sub x0,x0,x2 // total secondes to 01/01/2020
mov x6,x0
mov x1,60
udiv x0,x0,x1
udiv x0,x0,x1
mov x1,24
udiv x0,x0,x1
mov x7,x0
mov x1,(365 * 4 + 1)
udiv x9,x0,x1
lsl x9,x9,#2 // multiply by 4 = year1
mov x1,(365 * 4 + 1)
udiv x0,x7,x1
msub x10,x0,x1,x7
ldr x1,qAdrtbDayMonthYear
mov x8,3
mov x3,12
1:
mul x7,x3,x8
ldr x4,[x1,x7,lsl 3] // load days by year
cmp x10,x4
bge 2f
sub x8,x8,1
cmp x8,0
bne 1b
2: // x8 = yeax2
mov x5,#11
mul x7,x3,x8
lsl x7,x7,3
add x7,x7,x1
3:
ldr x4,[x7,x5,lsl 3] // load days by month
cmp x10,x4
bge 4f
subs x5,x5,1
bne 3b
4: // x5 = month - 1
mov x0,x6 // number secondes depuis 01/01/2020
ldr x1,qNbSecByDay
udiv x0,x6,x1
mov x1,7
udiv x2,x0,x1
msub x3,x2,x1,x0
add x2,x3,2
cmp x2,7
sub x3,x2,7
csel x2,x3,x2,ge
ldr x1,qAdrtbDayName
ldr x1,[x1,x2,lsl 3]
ldr x0,qAdrszMessResult1
bl strInsertAtCharInc // insert result at next // character
mov x3,x0
mov x7,12
mul x11,x7,x8
add x11,x11,x5
ldr x1,qAdrtbDayMonthYear
ldr x7,[x1,x11,lsl 3]
sub x0,x10,x7
add x0,x0,1 // final compute day
ldr x1,qAdrsZoneConv
bl conversion10 // this function do not zero final
mov x0,x3
ldr x1,qAdrsZoneConv
bl strInsertAtCharInc // insert result at first // character
mov x3,x0
ldr x1,qAdrtbMonthName
cmp x5,12
sub x2,x5,12
csel x5,x2,x5,ge
ldr x1,[x1,x5,lsl 3] // month name
mov x0,x3
bl strInsertAtCharInc // insert result at first // character
mov x3,x0
ldr x0,qYearStart
add x0,x0,x8
add x0,x0,x9 // final compute year = 2020 + yeax1 + yeax2
ldr x1,qAdrsZoneConv
bl conversion10 // this function do not zero final
mov x0,x3
ldr x1,qAdrsZoneConv
bl strInsertAtCharInc // insert result at first // character
bl affichageMess
100:
ldp x1,lr,[sp],16 // restaur 2 registers
ret // return to address lr x30
qAdrszMessResult1: .quad szMessResult1
qSecJan2020: .quad 1577836800
qAdrtbDayMonthYear: .quad tbDayMonthYear
qYearStart: .quad 2020
qAdrtbMonthName: .quad tbMonthName
qAdrtbDayName: .quad tbDayName
qNbSecByDay: .quad 3600 * 24
/********************************************************/
/* File Include fonctions */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
ABAP
report zdate.
data: lv_month type string,
lv_weekday type string,
lv_date type string,
lv_day type c.
call function 'DATE_COMPUTE_DAY'
exporting date = sy-datum
importing day = lv_day.
select single ltx from t247 into lv_month
where spras = sy-langu and
mnr = sy-datum+4(2).
select single langt from t246 into lv_weekday
where sprsl = sy-langu and
wotnr = lv_day.
concatenate lv_weekday ', ' lv_month ' ' sy-datum+6(2) ', ' sy-datum(4) into lv_date respecting blanks.
write lv_date.
concatenate sy-datum(4) '-' sy-datum+4(2) '-' sy-datum+6(2) into lv_date.
write / lv_date.
Action!
DEFINE PTR="CARD"
TYPE Date=[
INT year
BYTE month
BYTE day]
PTR ARRAY DayOfWeeks(7)
PTR ARRAY Months(12)
PROC Init()
DayOfWeeks(0)="Sunday" DayOfWeeks(1)="Monday"
DayOfWeeks(2)="Tuesday" DayOfWeeks(3)="Wednesday"
DayOfWeeks(4)="Thursday" DayOfWeeks(5)="Friday"
DayOfWeeks(6)="Saturday"
Months(0)="January" Months(1)="February"
Months(2)="March" Months(3)="April"
Months(4)="May" Months(5)="June"
Months(6)="July" Months(7)="August"
Months(8)="September" Months(9)="October"
Months(10)="November" Months(11)="December"
RETURN
;https://en.wikipedia.org/wiki/Determination_of_the_day_of_the_week#Sakamoto.27s_methods
BYTE FUNC DayOfWeek(Date POINTER d) ;1<=m<=12, y>1752
BYTE ARRAY t=[0 3 2 5 0 3 5 1 4 6 2 4]
BYTE res
INT y
y=d.year
IF d.month<3 THEN
y==-1
FI
res=(y+y/4-y/100+y/400+t(d.month-1)+d.day) MOD 7
RETURN (res)
PROC PrintB2(BYTE x)
IF x<10 THEN
Put('0)
FI
PrintB(x)
RETURN
PROC PrintDateShort(Date POINTER d)
PrintI(d.year) Put('-)
PrintB2(d.month) Put('-)
PrintB2(d.day)
RETURN
PROC PrintDateLong(Date POINTER d)
BYTE wd
wd=DayOfWeek(d)
Print(DayOfWeeks(wd)) Print(", ")
Print(Months(d.month-1)) Put(' )
PrintB(d.day) Print(", ")
PrintI(d.year)
RETURN
PROC Main()
Date d
Init()
;There is no function to get the current date
;on Atari 8-bit computer
d.year=2021 d.month=9 d.day=1
PrintDateShort(d) PutE()
PrintDateLong(d) PutE()
RETURN
- Output:
Screenshot from Atari 8-bit computer
2021-09-01 Wednesday, September 1, 2021
Ada
with Ada.Calendar; use Ada.Calendar;
with Ada.Calendar.Formatting; use Ada.Calendar.Formatting;
with Ada.Text_IO; use Ada.Text_IO;
procedure Date_Format is
function Image (Month : Month_Number) return String is
begin
case Month is
when 1 => return "January";
when 2 => return "February";
when 3 => return "March";
when 4 => return "April";
when 5 => return "May";
when 6 => return "June";
when 7 => return "July";
when 8 => return "August";
when 9 => return "September";
when 10 => return "October";
when 11 => return "November";
when 12 => return "December";
end case;
end Image;
function Image (Day : Day_Name) return String is
begin
case Day is
when Monday => return "Monday";
when Tuesday => return "Tuesday";
when Wednesday => return "Wednesday";
when Thursday => return "Thursday";
when Friday => return "Friday";
when Saturday => return "Saturday";
when Sunday => return "Sunday";
end case;
end Image;
Today : Time := Clock;
begin
Put_Line (Image (Today) (1..10));
Put_Line
( Image (Day_Of_Week (Today)) & ", "
& Image (Ada.Calendar.Month (Today))
& Day_Number'Image (Ada.Calendar.Day (Today)) & ","
& Year_Number'Image (Ada.Calendar.Year (Today))
);
end Date_Format;
- Output:
2008-10-03 Friday, October 3, 2008
ALGOL 68
Note: the format can be used for both printing and reading date data.
# define the layout of the date/time as provided by the call to local time #
STRUCT ( INT sec, min, hour, mday, mon, year, wday, yday, isdst) tm = (6,5,4,3,2,1,7,~,8);
FORMAT # some useful format declarations #
ymd repr = $4d,"-"2d,"-"2d$,
month repr = $c("January","February","March","April","May","June","July",
"August","September","October","November","December")$,
week day repr = $c("Sunday","Monday","Tuesday","Wednesday",
"Thursday","Friday","Saturday")$,
dmdy repr = $f(week day repr)", "f(month repr)" "g(-0)", "g(-4)$,
mon = $c("Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec")$,
wday = $c("Sun","Mon","Tue","Wed","Thu","Fri","Sat")$,
tz = $c("MSK","MSD")$,
unix time repr = $f(wday)" "f(mon)z-d," "dd,":"dd,":"dd," "f(tz)" "dddd$;
[]INT now = local time;
printf((ymd repr, now[year OF tm:mday OF tm], $l$));
printf((dmdy repr, now[wday OF tm], now[mon OF tm], now[mday OF tm], now[year OF tm], $l$));
printf((unix time repr, now[wday OF tm], now[mon OF tm], now[mday OF tm],
now[hour OF tm:sec OF tm], now[isdst OF tm]+1, now[year OF tm], $l$))
- Output:
2009-04-08 Wednesday, April 8, 2009 Wed Apr 8 18:04:02 MSD 2009
Apex
Datetime dtNow = datetime.now();
String strDt1 = dtNow.format('yyyy-MM-dd');
String strDt2 = dtNow.format('EEEE, MMMM dd, yyyy');
system.debug(strDt1); // "2007-11-10"
system.debug(strDt2); //"Sunday, November 10, 2007"
- Output:
2016-04-20 Wednesday, April 20, 2016
AppleScript
Idiomatic
This restores the legitimate code which has twice now been deleted by the poster of the hacks below. Explicitly: square brackets are not and have never been part of the AppleScript language and «class isot» as string is a hack someone discovered many years ago when it wasn't possible to coerce AppleScript month enums directly to integer and when AppleScript's string class used 8-bit characters. Back then, the coercion from string to «class isot» also worked. But this ended with the introduction of AppleScript 2.0 in 2007, when string, Unicode text, and text became synonymous terms for UTF-16 text. The ability to coerce from 8-bit text specifically to string was retained for compatibility with existing scripts and for reading non-Unicode text files. Other classes of text such C string were discontinued.
Whether or not they happen to work, to insist on posting code containing things which have never been part of the language without noting them as hacks, when they're entirely unnecessary, and deleting legitimate and effective code to make way for them, is seriously to misinform readers.
set {year:y, month:m, day:d, weekday:w} to (current date)
tell (y * 10000 + m * 100 + d) as text to set shortFormat to text 1 thru 4 & "-" & text 5 thru 6 & "-" & text 7 thru 8
set longFormat to (w as text) & (", " & m) & (space & d) & (", " & y)
return (shortFormat & linefeed & longFormat)
- Output:
"2020-10-28
Wednesday, October 28, 2020"
Hack alternative
AppleScript date
objects are very simple to manipulate, provided one is familiar with the slightly unintuitive nature of how they should be handled in order to be robust and produce the desired result across all systems. Despite the official documentation claiming otherwise, AppleScript is not able to parse date strings that don’t strictly adhere to the date and time format strings specified in System Preferences—thus it is a setting that is specific to one’s system, and won’t naturally port.
AppleScript provides properties and classes specifically for manipulating or constructing date objects that are not dependent on anything outwith the AppleScript language. In most cases, the current date
command provides a starting point, from which one gets current or sets new values for its day
, month
, year
, and time
properties and property classes to determine or affect the date a particular date object refers to.
Formatting is usually achieved by extracting individual date components, performing text manipulations (e.g. to prepend leading zeroes) on each of these, then concatenating these for the final result. The «class isot»
class doesn’t have a vernacular form and can only be accessed using its raw chevron syntactic form, which others may recognise from similar AppleScript classes such as «class furl»
, «class utf8»
and so forth. They can provide some useful—and, often, more reliable—features that can save the headache suffered by many when learning how the file
, POSIX file
, and alias
classes differ between one another, and then also with the way the same class can be implemented in ways or yield unexpected results when used in a context specific to a scriptable application.
«class isot»
and date
class objects can coerce to and from one another. The «class isot»
is an opaque data type wrapping the hexbytes of an ISO-8601 formatted datetime string. Sadly, it doesn’t permit one to use it to convert a string into hexbytes, but it is ideal for taking a date
reference via the «class isot»
intermediary form and coercing this to string
class (whose chevron syntax form is «class TEXT»
), but it will not coerce onto other AppleScript classes that are normally used interchangeably to represent strings, namely text
(«class ctxt»
) or unicode text
(«class utxt»
).
Both scripts provided below, contributed separately by different users, each make use of the features discussed above. The first demonstrates the simplest and most direct solution, but simplicity forces specificity, which limits what other algorithmic problems it could usefully or easily be adapted to solve. The latter borrows a functional approach and favours an initial investment to create the atomic handlers that pay off by providing the reusable building blocks of identical code that will be the composable functions all other scripts are assembled from sparing much of the need to write new code to solve the vast majority of problems on this site. Generality, versatility and adaptability of this approach can be proven mathematically.
tell (the current date)
set shortdate to text 1 thru 10 of (it as «class isot» as string)
set longdate to the contents of [its weekday, ", ", ¬
(its month), " ", day, ", ", year] as text
end tell
log the shortdate
log the longdate
- Output:
2020-09-11 Friday, September 11, 2020
Functional
Or, emphasising productivity and functional composition:
-- iso8601Short :: Date -> String
on iso8601Short(dte)
text 1 thru 10 of iso8601Local(dte)
end iso8601Short
-- longDate :: Date -> String
on longDate(dte)
tell dte
"" & its weekday & ", " & its month & " " & its day & ", " & year
end tell
end longDate
---------------------------- TEST --------------------------
on run
unlines(apList({iso8601Short, longDate}, ¬
{current date}))
end run
-------------------------- GENERIC -------------------------
-- Each member of a list of functions applied to
-- each of a list of arguments, deriving a list of new values
-- apList (<*>) :: [(a -> b)] -> [a] -> [b]
on apList(fs, xs)
set lst to {}
repeat with f in fs
tell mReturn(contents of f)
repeat with x in xs
set end of lst to |λ|(contents of x)
end repeat
end tell
end repeat
return lst
end apList
-- iso8601Local :: Date -> String
on iso8601Local(dte)
(dte as «class isot» as string)
end iso8601Local
-- mReturn :: First-class m => (a -> b) -> m (a -> b)
on mReturn(f)
-- 2nd class handler function lifted into 1st class script wrapper.
if script is class of f then
f
else
script
property |λ| : f
end script
end if
end mReturn
-- unlines :: [String] -> String
on unlines(xs)
-- A single string formed by the intercalation
-- of a list of strings with the newline character.
set {dlm, my text item delimiters} to ¬
{my text item delimiters, linefeed}
set s to xs as text
set my text item delimiters to dlm
s
end unlines
- Output:
2020-09-11 Friday, September 11, 2020
ARM Assembly
/* ARM assembly Raspberry PI */
/* program dateFormat.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 "Date : @/@/@ \n" @ message result
szMessResult1: .asciz "Date day : @ @ @ @ \n" @ message result
szJan: .asciz "Janvier"
szFev: .asciz "Février"
szMars: .asciz "Mars"
szAvril: .asciz "Avril"
szMai: .asciz "Mai"
szJuin: .asciz "Juin"
szJuil: .asciz "Juillet"
szAout: .asciz "Aout"
szSept: .asciz "Septembre"
szOct: .asciz "Octobre"
szNov: .asciz "Novembre"
szDec: .asciz "Décembre"
szLundi: .asciz "Lundi"
szMardi: .asciz "Mardi"
szMercredi: .asciz "Mercredi"
szJeudi: .asciz "Jeudi"
szVendredi: .asciz "Vendredi"
szSamedi: .asciz "Samedi"
szDimanche: .asciz "Dimanche"
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
tbMonthName: .int szJan
.int szFev
.int szMars
.int szAvril
.int szMai
.int szJuin
.int szJuil
.int szAout
.int szSept
.int szOct
.int szNov
.int szDec
tbDayName: .int szLundi
.int szMardi
.int szMercredi
.int szJeudi
.int szVendredi
.int szSamedi
.int szDimanche
/*********************************/
/* 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 r1,iAdrstTVal
ldr r0,[r1,#timeval_sec] @ timestemp in second
bl dateFormatNum
ldr r0,[r1,#timeval_sec] @ timestemp in second
bl dateFormatAlpha
ldr r0,iTStest1
bl dateFormatNum
ldr r0,iTStest1
bl dateFormatAlpha
ldr r0,iTStest2
bl dateFormatNum
ldr r0,iTStest2
bl dateFormatAlpha
ldr r0,iTStest3
bl dateFormatNum
ldr r0,iTStest3
bl dateFormatAlpha
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
iAdrszCarriageReturn: .int szCarriageReturn
iAdrsZoneConv: .int sZoneConv
iTStest1: .int 1609508339 @ 01/01/2021
iTStest2: .int 1657805939 @ 14/07/2022
iTStest3: .int 1767221999 @ 31/12/2025
/******************************************************************/
/* date format numeric */
/******************************************************************/
/* r0 contains the timestamp in seconds */
dateFormatNum:
push {r1-r11,lr} @ save registers
ldr r2,iSecJan2020
sub r0,r0,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 r4,[r1,r11,lsl #2] @ load days by year
cmp r10,r4
bge 2f
sub r2,r2,#1
cmp r2,#0
bne 1b
2: @ r2 = year2
mov r5,#11
mul r11,r3,r2
lsl r11,#2
add r11,r1 @ table address
3:
ldr r4,[r11,r5,lsl #2] @ load days by month
cmp r10,r4
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 r11,#0 @ store zero final
strb r11,[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
cmp r0,#12
subgt r0,#12
ldr r1,iAdrsZoneConv
bl conversion10
mov r11,#0 @ store zero final
strb r11,[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 r11,#0 @ store zero final
strb r11,[r1,r0]
mov r0,r3
ldr r1,iAdrsZoneConv
bl strInsertAtCharInc @ insert result at next @ character
bl affichageMess
100:
pop {r1-r11,lr} @ restaur registers
bx lr @ return
iAdrszMessResult: .int szMessResult
/******************************************************************/
/* date format alphanumeric */
/******************************************************************/
/* r0 contains the timestamp in seconds */
dateFormatAlpha:
push {r1-r10,lr} @ save registers
ldr r2,iSecJan2020
sub r0,r0,r2 @ total secondes to 01/01/2020
mov r6,r0
mov r1,#60
bl division
mov r0,r2
mov r1,#60
bl division
mov r0,r2
mov r1,#24
bl division
mov r0,r2
mov r8,r0
mov r1,#(365 * 4 + 1)
bl division
lsl r9,r2,#2 @ multiply by 4 = year1
mov r1,#(365 * 4 + 1)
mov r0,r8
bl division
mov r10,r3 @ reste
ldr r1,iAdrtbDayMonthYear
mov r7,#3
mov r3,#12
1:
mul r8,r3,r7
ldr r4,[r1,r8,lsl #2] @ load days by year
cmp r10,r4
bge 2f
sub r7,r7,#1
cmp r7,#0
bne 1b
2: @ r7 = year2
mov r5,#11
mul r8,r3,r7
lsl r8,#2
add r8,r1
3:
ldr r4,[r8,r5,lsl #2] @ load days by month
cmp r10,r4
bge 4f
subs r5,r5,#1
bne 3b
4: @ r5 = month - 1
mov r0,r6 @ number secondes depuis 01/01/2020
ldr r1,iNbSecByDay
bl division
mov r0,r2
mov r1,#7
bl division
add r2,r3,#2
cmp r2,#7
subge r2,#7
ldr r1,iAdrtbDayName
ldr r1,[r1,r2,lsl #2]
ldr r0,iAdrszMessResult1
bl strInsertAtCharInc @ insert result at next @ character
mov r3,r0
mov r8,#12
mul r11,r8,r7
add r11,r5
ldr r1,iAdrtbDayMonthYear
ldr r8,[r1,r11,lsl #2]
sub r0,r10,r8
add r0,r0,#1 @ final compute day
ldr r1,iAdrsZoneConv
bl conversion10 @ this function do not zero final
mov r8,#0 @ store zero final
strb r8,[r1,r0]
mov r0,r3
ldr r1,iAdrsZoneConv
bl strInsertAtCharInc @ insert result at first @ character
mov r3,r0
ldr r1,iAdrtbMonthName
cmp r5,#12
subge r5,#12
ldr r1,[r1,r5,lsl #2] @ month name
mov r0,r3
bl strInsertAtCharInc @ insert result at first @ character
mov r3,r0
ldr r0,iYearStart
add r0,r7
add r0,r9 @ final compute year = 2020 + year1 + year2
ldr r1,iAdrsZoneConv
bl conversion10 @ this function do not zero final
mov r8,#0 @ store zero final
strb r8,[r1,r0]
mov r0,r3
ldr r1,iAdrsZoneConv
bl strInsertAtCharInc @ insert result at first @ character
bl affichageMess
100:
pop {r1-r10,lr} @ restaur registers
bx lr @ return
iAdrszMessResult1: .int szMessResult1
iSecJan2020: .int 1577836800
iAdrtbDayMonthYear: .int tbDayMonthYear
iYearStart: .int 2020
iAdrtbMonthName: .int tbMonthName
iAdrtbDayName: .int tbDayName
iNbSecByDay: .int 3600 * 24
/***************************************************/
/* ROUTINES INCLUDE */
/***************************************************/
.include "../affichage.inc"
- Output:
Date : 30/3/2020 Date day : Lundi 30 Mars 2020 Date : 1/1/2021 Date day : Vendredi 1 Janvier 2021 Date : 14/7/2022 Date day : Jeudi 14 Juillet 2022 Date : 31/12/2025 Date day : Mercredi 31 Décembre 2025
Arturo
currentTime: now
print to :string.format: "YYYY-MM-dd" currentTime
print to :string.format: "dddd, MMMM dd, YYYY" currentTime
- Output:
2021-03-11 Thursday, March 11, 2021
AutoHotkey
FormatTime, Date1, , yyyy-MM-dd ; "2007-11-10"
FormatTime, Date2, , LongDate ; "Sunday, November 10, 2007"
MsgBox %Date1% `n %Date2%
AutoIt
This solution uses the locale settings for names of days and months.
#include <Date.au3>
$iYear = 2007
$iMonth = 11
$iDay = 10
ConsoleWrite(StringFormat('%4d-%02d-%02d', $iYear, $iMonth, $iDay) & @LF)
$iWeekDay = _DateToDayOfWeekISO($iYear, $iMonth, $iDay)
ConsoleWrite(StringFormat('%s, %s %02d, %4d', _GetLongDayLocale($iWeekDay), _GetLongMonthLocale($iMonth), $iDay, $iYear) & @LF)
Func _GetLongDayLocale($_iWeekDay) ; 1..7 Monday=1
Local $aDayName[8] = [0, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30]
Return GetLocaleInfo($aDayName[$_iWeekDay])
EndFunc
Func _GetLongMonthLocale($_iMonth) ; 1..12 January=1
Local $aMonthName[13] = [0, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43]
Return GetLocaleInfo($aMonthName[$_iMonth])
EndFunc
Func GetLocaleInfo($_LCType)
Local $ret, $LCID, $sBuffer, $iLen
$ret = DllCall('kernel32', 'long', 'GetSystemDefaultLCID')
$LCID = $ret[0]
$ret = DllCall('kernel32', 'long', 'GetLocaleInfo', 'long', $LCID, 'long', $_LCType, 'str', $sBuffer, 'long', 0)
$iLen = $ret[0]
$ret = DllCall('kernel32', 'long', 'GetLocaleInfo', 'long', $LCID, 'long', $_LCType, 'str', $sBuffer, 'long', $iLen)
Return $ret[3]
EndFunc
- Output:
2007-11-10 Samstag, November 10, 2007
--BugFix (talk) 16:24, 17 November 2013 (UTC)
AWK
$ awk 'BEGIN{t=systime();print strftime("%Y-%m-%d",t)"\n"strftime("%A, %B %d, %Y",t)}'
2009-05-15
Friday, May 15, 2009
BaCon
' Date format
n = NOW
PRINT YEAR(n), MONTH(n), DAY(n) FORMAT "%ld-%02ld-%02ld\n"
PRINT WEEKDAY$(n), MONTH$(n), DAY(n), YEAR(n) FORMAT "%s, %s %02ld, %ld\n"
- Output:
prompt$ ./date-format 2017-02-17 Friday, February 17, 2017
BASIC
#include "vbcompat.bi"
DIM today As Double = Now()
PRINT Format(today, "yyyy-mm-dd")
PRINT Format(today, "dddd, mmmm d, yyyy")
Batch File
@echo off
setlocal enabledelayedexpansion
:: Define arrays of days/months we'll need
set daynames=Monday Tuesday Wednesday Thursday Friday Saturday Sunday
set monthnames=January February March April May June July August September October November December
:: Separate the output of the 'date /t' command (outputs in the format of "Sun 16/04/2017") into 4 variables
for /f "tokens=1,2,3,4 delims=/ " %%i in ('date /t') do (
set dayname=%%i
set day=%%j
set month=%%k
set year=%%l
)
:: Crosscheck the first 3 letters of every word in %daynames% to the 3 letter day name found previously
for %%i in (%daynames%) do (
set tempdayname=%%i
set comparedayname=!tempdayname:~0,3!
if "%dayname%"=="!comparedayname!" set fulldayname=%%i
)
:: Variables starting with "0" during the 'set /a' command are treated as octal numbers. To avoid this, if the first character of %month% is "0", it is removed
if "%month:~0,1%"=="0" set monthtemp=%month:~1,1%
set monthcount=0
:: Iterates through %monthnames% and when it reaches the amount of iterations dictated by %month%, sets %monthname% as the current month being iterated through
for %%i in (%monthnames%) do (
set /a monthcount+=1
if %monthtemp%==!monthcount! set monthname=%%i
)
echo %year%-%month%-%day%
echo %fulldayname%, %monthname% %day%, %year%
pause>nul
- Output:
2017-04-16 Sunday, 16, 2017
BBC BASIC
daysow$ = "Sunday Monday Tuesday Wednesday Thursday Friday Saturday"
months$ = "January February March April May June " + \
\ "July August September October November December"
date$ = TIME$
dayow% = (INSTR(daysow$, MID$(date$,1,3)) + 9) DIV 10
month% = (INSTR(months$, MID$(date$,8,3)) + 9) DIV 10
PRINT MID$(date$,12,4) "-" RIGHT$("0"+STR$month%,2) + "-" + MID$(date$,5,2)
PRINT FNrtrim(MID$(daysow$, dayow%*10-9, 10)) ", " ;
PRINT FNrtrim(MID$(months$, month%*10-9, 10)) " " ;
PRINT MID$(date$,5,2) ", " MID$(date$,12,4)
END
DEF FNrtrim(A$)
WHILE RIGHT$(A$) = " " A$ = LEFT$(A$) : ENDWHILE
= A$
Beads
// time_to_str(format, time, city, lang) // format directives: // [sun] - abbreviated weekday, e.g. Sun // [sunday] - full weekday name, e.g. Sunday // [jan] - abbrev month // [january] - full month // [day] - day of the month 1, 2, ..31 // [day2] - day of the month as two digits 01, 02, ..31 // [hour] - hour 00, 01, 03..23 // [hour12] - hour 1..12 // [julian] - day of the year 1..366 // [month] - month 1..12 // [month2] - month as two digits 01, 02, ..12 // [minute] - Minute 00, 01, 02..59 // [am] - AM or PM // [sec] - second 00, 01, 02..61 // [msec] - millisecond 000...999 // [week sun] - week number of the year, sunday based (ranges 01-53, per ISO spec) // [week mon] - week number of the year, monday based // [year] - year with century 2024 // [year2] - year without century 00, 01, ..99 // [date] - default date format (e.g. Jan 14, 2015 ) // [date time] - (e.g. Jan 14, 2015 3:45 PM) // [iso date] = [year]-[month2]-[day2], e.g. 2015-02-22 // [iso time] = [hour]:[minute]:[second], e.g. 18:06:05
beads 1 program 'Date format'
calc main_init
log time_to_str('[iso date]')
log time_to_str('[sunday], [january] [day2], [year]')
- Output:
2021-03-11 Thursday, March 11, 2021
C
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#define MAX_BUF 50
int main(void)
{
char buf[MAX_BUF];
time_t seconds = time(NULL);
struct tm *now = localtime(&seconds);
const char *months[] = {"January", "February", "March", "April", "May", "June",
"July", "August", "September", "October", "November", "December"};
const char *days[] = {"Sunday", "Monday", "Tuesday", "Wednesday","Thursday","Friday","Saturday"};
(void) printf("%d-%d-%d\n", now->tm_year + 1900, now->tm_mon + 1, now->tm_mday);
(void) printf("%s, %s %d, %d\n",days[now->tm_wday], months[now->tm_mon],
now->tm_mday, now->tm_year + 1900);
/* using the strftime (the result depends on the locale) */
(void) strftime(buf, MAX_BUF, "%A, %B %e, %Y", now);
(void) printf("%s\n", buf);
return EXIT_SUCCESS;
}
- Output:
2009-5-13 Wednesday, May 13, 2009 Wednesday, May 13, 2009
C#
using System;
namespace RosettaCode.DateFormat
{
class Program
{
static void Main(string[] args)
{
DateTime today = DateTime.Now.Date;
Console.WriteLine(today.ToString("yyyy-MM-dd"));
Console.WriteLine(today.ToString("dddd, MMMMM d, yyyy"));
}
}
}
C++
// Display the current date in the formats of "2007-11-10"
// and "Sunday, November 10, 2007".
#include <vector>
#include <string>
#include <iostream>
#include <ctime>
/** Return the current date in a string, formatted as either ISO-8601
* or "Weekday-name, Month-name Day, Year".
*
* The date is initialized when the object is created and will return
* the same date for the lifetime of the object. The date returned
* is the date in the local timezone.
*/
class Date
{
struct tm ltime;
public:
/// Default constructor.
Date()
{
time_t t = time(0);
localtime_r(&t, <ime);
}
/** Return the date based on a format string. The format string is
* fed directly into strftime(). See the strftime() documentation
* for information on the proper construction of format strings.
*
* @param[in] fmt is a valid strftime() format string.
*
* @return a string containing the formatted date, or a blank string
* if the format string was invalid or resulted in a string that
* exceeded the internal buffer length.
*/
std::string getDate(const char* fmt)
{
char out[200];
size_t result = strftime(out, sizeof out, fmt, <ime);
return std::string(out, out + result);
}
/** Return the date in ISO-8601 date format.
*
* @return a string containing the date in ISO-8601 date format.
*/
std::string getISODate() {return getDate("%F");}
/** Return the date formatted as "Weekday-name, Month-name Day, Year".
*
* @return a string containing the date in the specified format.
*/
std::string getTextDate() {return getDate("%A, %B %d, %Y");}
};
int main()
{
Date d;
std::cout << d.getISODate() << std::endl;
std::cout << d.getTextDate() << std::endl;
return 0;
}
- Output:
2009-05-14 Thursday, May 14, 2009
Clojure
(let [now (.getTime (java.util.Calendar/getInstance))
f1 (java.text.SimpleDateFormat. "yyyy-MM-dd")
f2 (java.text.SimpleDateFormat. "EEEE, MMMM dd, yyyy")]
(println (.format f1 now))
(println (.format f2 now)))
- Output:
2009-12-06 Sunday, December 06, 2009
COBOL
IDENTIFICATION DIVISION.
PROGRAM-ID. Date-Format.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 Days-Area.
03 Days-Data.
05 FILLER PIC X(9) VALUE "Monday".
05 FILLER PIC X(9) VALUE "Tuesday".
05 FILLER PIC X(9) VALUE "Wednesday".
05 FILLER PIC X(9) VALUE "Thursday".
05 FILLER PIC X(9) VALUE "Friday".
05 FILLER PIC X(9) VALUE "Saturday".
05 FILLER PIC X(9) VALUE "Sunday".
03 Days-Values REDEFINES Days-Data.
05 Days-Table PIC X(9) OCCURS 7 TIMES.
01 Months-Area.
03 Months-Data.
05 FILLER PIC X(9) VALUE "January".
05 FILLER PIC X(9) VALUE "February".
05 FILLER PIC X(9) VALUE "March".
05 FILLER PIC X(9) VALUE "April".
05 FILLER PIC X(9) VALUE "May".
05 FILLER PIC X(9) VALUE "June".
05 FILLER PIC X(9) VALUE "July".
05 FILLER PIC X(9) VALUE "August".
05 FILLER PIC X(9) VALUE "September".
05 FILLER PIC X(9) VALUE "October".
05 FILLER PIC X(9) VALUE "November".
05 FILLER PIC X(9) VALUE "December".
03 Months-Values REDEFINES Months-Data.
05 Months-Table PIC X(9) OCCURS 12 TIMES.
01 Current-Date-Str.
03 Current-Year PIC X(4).
03 Current-Month PIC X(2).
03 Current-Day PIC X(2).
01 Current-Day-Of-Week PIC 9.
PROCEDURE DIVISION.
MOVE FUNCTION CURRENT-DATE (1:8) TO Current-Date-Str
DISPLAY Current-Year "-" Current-Month "-" Current-Day
ACCEPT Current-Day-Of-Week FROM DAY-OF-WEEK
DISPLAY
FUNCTION TRIM(
Days-Table (FUNCTION NUMVAL(Current-Day-Of-Week)))
", "
FUNCTION TRIM(
Months-Table (FUNCTION NUMVAL(Current-Month)))
" "
Current-Day
", "
Current-Year
END-DISPLAY
GOBACK
.
CoffeeScript
ECMAScript ≥ 5.1
Is supported by at least: Chrome 24, Firefox/Gecko 29, IE 11, Opera 15, and Node.js (at least as of 2015).
date = new Date
console.log date.toLocaleDateString 'en-GB',
month: '2-digit'
day: '2-digit'
year: 'numeric'
.split('/').reverse().join '-'
console.log date.toLocaleDateString 'en-US',
weekday: 'long'
month: 'long'
day: 'numeric'
year: 'numeric'
Portable version
# JS does not have extensive formatting support out of the box. This code shows
# how you could create a date formatter object.
DateFormatter = ->
weekdays = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
pad = (n) ->
if n < 10
"0" + n
else
n
brief: (date) ->
month = 1 + date.getMonth()
"#{date.getFullYear()}-#{pad month}-#{pad date.getDate()}"
verbose: (date) ->
weekday = weekdays[date.getDay()]
month = months[date.getMonth()]
day = date.getDate()
year = date.getFullYear();
"#{weekday}, #{month} #{day}, #{year}"
formatter = DateFormatter()
date = new Date()
console.log formatter.brief(date)
console.log formatter.verbose(date)
- Output:
> coffee date_format.coffee 2012-01-14 Saturday, January 14, 2012
ColdFusion
<cfoutput>
#dateFormat(Now(), "YYYY-MM-DD")#<br />
#dateFormat(Now(), "DDDD, MMMM DD, YYYY")#
</cfoutput>
Common Lisp
(defconstant *day-names*
#("Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday" "Sunday"))
(defconstant *month-names*
#(nil "January" "February" "March" "April" "May" "June" "July"
"August" "September" "October" "November" "December"))
(multiple-value-bind (sec min hour date month year day daylight-p zone) (get-decoded-time)
(format t "~4d-~2,'0d-~2,'0d~%" year month date)
(format t "~a, ~a ~d, ~4d~%"
(aref *day-names* day) (aref *month-names* month) date year))
With the local-time library:
(local-time:format-timestring nil (local-time:now) :format '(:year "-" (:month 2) "-" (:day 2)))
;; => "2019-11-13"
(local-time:format-timestring nil (local-time:now) :format '(:long-weekday ", " :long-month #\space (:day 2) ", " :year))
;; => "Wednesday, November 13, 2019"
Component Pascal
BlackBox Component Builder
MODULE DateFormat;
IMPORT StdLog, Dates;
PROCEDURE Do*;
VAR
d: Dates.Date;
resp: ARRAY 64 OF CHAR;
BEGIN
Dates.GetDate(d);
Dates.DateToString(d,Dates.short,resp);
StdLog.String(":> " + resp);StdLog.Ln;
Dates.DateToString(d,Dates.abbreviated,resp);
StdLog.String(":> " + resp);StdLog.Ln;
Dates.DateToString(d,Dates.long,resp);
StdLog.String(":> " + resp);StdLog.Ln;
Dates.DateToString(d,Dates.plainAbbreviated,resp);
StdLog.String(":> " + resp);StdLog.Ln;
Dates.DateToString(d,Dates.plainLong,resp);
StdLog.String(":> " + resp);StdLog.Ln;
END Do;
END DateFormat.
Execute: ^Q DateFormat.Do
- Output:
Spanish localization
:> 01/09/2013 :> dom, 01 de sep de 2013 :> domingo, 01 de septiembre de 2013 :> 01 de sep de 2013 :> 01 de septiembre de 2013
Crystal
require "time"
time = Time.local
puts time.to_s("%Y-%m-%d")
puts time.to_s("%A, %B %d, %Y")
D
module datetimedemo ;
import tango.time.Time ;
import tango.text.locale.Locale ;
import tango.time.chrono.Gregorian ;
import tango.io.Stdout ;
void main() {
Gregorian g = new Gregorian ;
Stdout.layout = new Locale; // enable Stdout to handle date/time format
Time d = g.toTime(2007, 11, 10, 0, 0, 0, 0, g.AD_ERA) ;
Stdout.format("{:yyy-MM-dd}", d).newline ;
Stdout.format("{:dddd, MMMM d, yyy}", d).newline ;
d = g.toTime(2008, 2, 1, 0, 0, 0, 0, g.AD_ERA) ;
Stdout.format("{:dddd, MMMM d, yyy}", d).newline ;
}
- Output:
2007-11-10 Saturday, November 10, 2007 Friday, February 1, 2008
Delphi
ShowMessage(FormatDateTime('yyyy-mm-dd', Now) +#13#10+ FormatDateTime('dddd, mmmm dd, yyyy', Now));
- Output:
2022-02-16 Wednesday, February 16, 2022 Redirecting to
Diego
me_lang(en)_cal(gregorian);
me_msg()_now()_format(yyyy-mm-dd);
me_msg()_now()_format(eeee, mmmm dd, yyyy);
EasyLang
func wkday year month day .
adj = (14 - month) div 12
mm = month + 12 * adj - 2
yy = year - adj
r = day + (13 * mm - 1) div 5 + yy + yy div 4 - yy div 100 + yy div 400
return r mod 7 + 1
.
month$[] = [ "January" "February" "March" "April" "May" "June" "July" "August" "September" "October" "November" "December" ]
wday$[] = [ "Sunday" "Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday" ]
#
s$ = timestr systime
y$ = substr s$ 1 4
y = number y$
m$ = substr s$ 6 2
m = number m$
d$ = substr s$ 9 2
d = number d$
#
print y$ & "-" & m$ & "-" & d$
print wday$[wkday y m d] & ", " & month$[m] & " " & d & ", " & y
- Output:
2024-07-22 Monday, July 22, 2024
Ed
Using date is cheating, but ed has no built-in date fetching/formatting. Most other languages use strftime, which is basically the same thing, anyway.
H
!date +"\%Y-\%m-\%d"
!date +"\%A, \%B \%d, \%Y"
Q
EGL
// 2012-09-26
SysLib.writeStdout(StrLib.formatDate(DateTimeLib.currentDate(), "yyyy-MM-dd"));
// Wednesday, September 26, 2012
SysLib.setLocale("en", "US");
SysLib.writeStdout(StrLib.formatDate(DateTimeLib.currentDate(), "EEEE, MMMM dd, yyyy"));
- Output:
2012-09-26 Wednesday, September 26, 2012
Elixir
defmodule Date_format do
def iso_date, do: Date.utc_today |> Date.to_iso8601
def iso_date(year, month, day), do: Date.from_erl!({year, month, day}) |> Date.to_iso8601
def long_date, do: Date.utc_today |> long_date
def long_date(year, month, day), do: Date.from_erl!({year, month, day}) |> long_date
@months Enum.zip(1..12, ~w[January February March April May June July August September October November December])
|> Map.new
@weekdays Enum.zip(1..7, ~w[Monday Tuesday Wednesday Thursday Friday Saturday Sunday])
|> Map.new
def long_date(date) do
weekday = Date.day_of_week(date)
"#{@weekdays[weekday]}, #{@months[date.month]} #{date.day}, #{date.year}"
end
end
IO.puts Date_format.iso_date
IO.puts Date_format.long_date
IO.puts Date_format.iso_date(2007,11,10)
IO.puts Date_format.long_date(2007,11,10)
- Output:
2017-02-26 Sunday, February 26, 2017 2007-11-10 Saturday, November 10, 2007
Emacs Lisp
(format-time-string "%Y-%m-%d")
(format-time-string "%F") ;; new in Emacs 24
;; => "2015-11-08"
(format-time-string "%A, %B %e, %Y")
;; => "Sunday, November 8, 2015"
%e
is blank-padded day number, or %d
for zero-padded. Month and weekday names follow the current locale. On a POSIX style system this is the usual LC_TIME
or LC_ALL
environment variables. GNU Emacs variable system-time-locale
can override this if desired.
Erlang
-module(format_date).
-export([iso_date/0, iso_date/1, iso_date/3, long_date/0, long_date/1, long_date/3]).
-import(calendar,[day_of_the_week/1]).
-import(io,[format/2]).
-import(lists,[append/1]).
iso_date() -> iso_date(date()).
iso_date(Year, Month, Day) -> iso_date({Year, Month, Day}).
iso_date(Date) ->
format("~4B-~2..0B-~2..0B~n", tuple_to_list(Date)).
long_date() -> long_date(date()).
long_date(Year, Month, Day) -> long_date({Year, Month, Day}).
long_date(Date = {Year, Month, Day}) ->
Months = { "January", "February", "March", "April",
"May", "June", "July", "August",
"September", "October", "November", "December" },
Weekdays = { "Monday", "Tuesday", "Wednesday", "Thursday",
"Friday", "Saturday", "Sunday" },
Weekday = day_of_the_week(Date),
WeekdayName = element(Weekday, Weekdays),
MonthName = element(Month, Months),
append([WeekdayName, ", ", MonthName, " ", integer_to_list(Day), ", ",
integer_to_list(Year)]).
Euphoria
constant days = {"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"}
constant months = {"January","February","March","April","May","June",
"July","August","September","October","November","December"}
sequence now
now = date()
now[1] += 1900
printf(1,"%d-%02d-%02d\n",now[1..3])
printf(1,"%s, %s %d, %d\n",{days[now[7]],months[now[2]],now[3],now[1]})
F#
"F# Interactive" session:
> open System;;
> Console.WriteLine( DateTime.Now.ToString("yyyy-MM-dd") );;
2010-08-13
> Console.WriteLine( "{0:D}", DateTime.Now );;
Friday, August 13, 2010
Factor
USING: formatting calendar io ;
now "%Y-%m-%d" strftime print
now "%A, %B %d, %Y" strftime print
Fantom
Today's date can be retrieved using 'Date.today'. The 'toLocale' method can be passed formatting information to determine how the date should be represented as a string. The rules are described at http://fantom.org/doc/sys/Date.html#toLocale
fansh> Date.today.toLocale("YYYY-MM-DD")
2011-02-24
fansh> Date.today.toLocale("WWWW, MMMM DD, YYYY")
Thursday, February 24, 2011
Forth
: .-0 ( n -- n )
[char] - emit
dup 10 < if [char] 0 emit then ;
: .short-date
time&date ( s m h D M Y )
1 u.r .-0 1 u.r .-0 1 u.r
drop drop drop ;
: str-table
create ( n -- ) 0 do , loop
does> ( n -- str len ) swap cells + @ count ;
here ," December"
here ," November"
here ," October"
here ," September"
here ," August"
here ," July"
here ," June"
here ," May"
here ," April"
here ," March"
here ," February"
here ," January"
12 str-table months
here ," Sunday"
here ," Saturday"
here ," Friday"
here ," Thursday"
here ," Wednesday"
here ," Tuesday"
here ," Monday"
7 str-table weekdays
\ Zeller's Congruence
: zeller ( m -- days since March 1 )
9 + 12 mod 1- 26 10 */ 3 + ;
: weekday ( d m y -- 0..6 ) \ Monday..Sunday
over 3 < if 1- then
dup 4 /
over 100 / -
over 400 / + +
swap zeller + +
1+ 7 mod ;
: 3dup dup 2over rot ;
: .long-date
time&date ( s m h D M Y )
3dup weekday weekdays type ." , "
>R 1- months type space 1 u.r ." , " R> .
drop drop drop ;
Version 2: Meta Language
Forth is less of a language and more of an extensible toolkit of simple routines. This version attempts to demonstrate using the simple routines to extend Forth. Then using the language extensions and the power of concatenative language to solve the problem. This solution could create numerous date formats as one line definitions now that we have our "date" words defined. Typically these extensions would be saved as a library file.
\ Build up a "language" for date formatting
\ utility words
: UNDER+ ( a b c -- a+c b ) ROT + SWAP ;
: 3DUP ( a b c -- a b c a b c ) 2 PICK 2 PICK 2 PICK ;
: WRITE$ ( caddr -- ) COUNT TYPE ; \ print a counted string
: ',' ( -- ) ." , " ;
: '-' ( -- ) ." -" ;
\ day of week calculation
\ "This is an algorithm I've carried with me for 35 years,
\ originally in Assembler and Fortran II."
\ It counts the number of days from March 1, 1900."
\ Wil Baden R.I.P.
\ *****************************************************
\ **WARNING** only good until 2078 on 16 bit machine **
\ *****************************************************
DECIMAL
: CDAY ( dd mm yyyy -- century_day )
-3 UNDER+ OVER 0<
IF 12 UNDER+ 1- THEN
1900 - 1461 4 */ SWAP 306 * 5 + 10 / + + ;
: DOW ( cday -- day_of_week ) 2 + 7 MOD 1+ ; ( 7 is Sunday)
\ formatted number printers
: ##. ( n -- ) 0 <# # # #> TYPE ;
: ####. ( n -- ) 0 <# # # # # #> TYPE ;
\ make some string list words
: LIST[ ( -- ) !CSP 0 C, ; \ list starts with 0 bytes, record stack pos.
: ]LIST ( -- ) 0 C, ALIGN ?CSP ; \ '0' ends list, check stack
: NEXT$ ( $[1] -- $[2] ) COUNT + ; \ get next string
: NTH$ ( n list -- $addr ) SWAP 0 DO NEXT$ LOOP ; \ get nth string
: " ( -- ) [CHAR] " WORD C@ CHAR+ ALLOT ; \ compile text upto "
\ make the lists
CREATE MONTHS
LIST[ " January" " February" " March" " April" " May" " June" " July"
" August" " September" " October" " November" " December" ]LIST
CREATE DAYS
LIST[ " Monday" " Tuesday" " Wednesday" " Thursday"
" Friday" " Saturday" " Sunday" ]LIST
\ expose lists as indexable arrays that print the string
: ]MONTH$. ( n -- ) MONTHS NTH$ WRITE$ ;
: ]DAY$. ( n -- ) DAYS NTH$ WRITE$ ;
\ ===========================================
\ Rosetta Task Code Begins
\ Rosetta Date Format 1
: Y-M-D. ( d m y -- ) ####. '-' ##. '-' ##. ;
\ Rosetta Date Format 2
: LONG.DATE ( d m y -- )
3DUP CDAY DOW ]DAY$. ',' -ROT ]MONTH$. SPACE ##. ',' ####. ;
Test at the Forth Console
5 7 2018 Y-M-D. 2018-07-05 ok
ok
5 7 2018 LONG.DATE Thursday, July 05, 2018 ok
Fortran
The subroutine DATE_AND_TIME does not return day of week information so we have to write our own function for that
PROGRAM DATE
IMPLICIT NONE
INTEGER :: dateinfo(8), day
CHARACTER(9) :: month, dayname
CALL DATE_AND_TIME(VALUES=dateinfo)
SELECT CASE(dateinfo(2))
CASE(1)
month = "January"
CASE(2)
month = "February"
CASE(3)
month = "March"
CASE(4)
month = "April"
CASE(5)
month = "May"
CASE(6)
month = "June"
CASE(7)
month = "July"
CASE(8)
month = "August"
CASE(9)
month = "September"
CASE(10)
month = "October"
CASE(11)
month = "November"
CASE(12)
month = "December"
END SELECT
day = Day_of_week(dateinfo(3), dateinfo(2), dateinfo(1))
SELECT CASE(day)
CASE(0)
dayname = "Saturday"
CASE(1)
dayname = "Sunday"
CASE(2)
dayname = "Monday"
CASE(3)
dayname = "Tuesday"
CASE(4)
dayname = "Wednesday"
CASE(5)
dayname = "Thursday"
CASE(6)
dayname = "Friday"
END SELECT
WRITE(*,"(I0,A,I0,A,I0)") dateinfo(1),"-", dateinfo(2),"-", dateinfo(3)
WRITE(*,"(4(A),I0,A,I0)") trim(dayname), ", ", trim(month), " ", dateinfo(3), ", ", dateinfo(1)
CONTAINS
FUNCTION Day_of_week(d, m, y)
INTEGER :: Day_of_week, j, k
INTEGER, INTENT(IN) :: d, m, y
j = y / 100
k = MOD(y, 100)
Day_of_week = MOD(d + (m+1)*26/10 + k + k/4 + j/4 + 5*j, 7)
END FUNCTION Day_of_week
END PROGRAM DATE
- Output:
2008-12-14 Sunday, December 14, 2008
FreeBASIC
' FB 1.05.0 Win64
#Include "vbcompat.bi"
Dim d As Long = Now
Print "This example was created on : "; Format(d, "yyyy-mm-dd")
Print "In other words on : "; Format(d, "dddd, mmmm d, yyyy")
Print
Print "Press any key to quit the program"
Sleep
- Output:
This example was created on : 2016-10-02 In other words on : Sunday, October 2, 2016
Free Pascal
program Format_Date_Time;
uses
SysUtils;
begin
WriteLn(FormatDateTime('yyyy-mm-dd', Now) +#13#10+ FormatDateTime('dddd, mmmm dd, yyyy', Now));
end.
- Output:
2022-02-16 Wednesday, February 16, 2022
Frink
println[now[] -> ### yyyy-MM-dd ###]
println[now[] -> ### EEEE, MMMM d, yyyy ###]
FunL
println( format('%tF', $date) )
println( format('%1$tA, %1$tB %1$td, %1$tY', $date) )
FutureBasic
window 1
print date(@"yyyy-MM-dd")
print date(@"EEEE, MMMM dd, yyyy")
HandleEvents
Gambas
You can run this code. Copy the code, click this link, paste it in and press 'Run !'
Public Sub Main()
Print Format(Now, "yyyy - mm - dd")
Print Format(Now, "dddd, mmmm dd, yyyy")
End
Output:
2017 - 05 - 27 Saturday, May 27, 2017
Go
In an interesting design, you specify your format by providing the format for the date and time 01/02 03:04:05PM '06 -0700
package main
import "time"
import "fmt"
func main() {
fmt.Println(time.Now().Format("2006-01-02"))
fmt.Println(time.Now().Format("Monday, January 2, 2006"))
}
- Output:
2011-12-02 Friday, December 2, 2011
Groovy
Solution:
def isoFormat = { date -> date.format("yyyy-MM-dd") }
def longFormat = { date -> date.format("EEEE, MMMM dd, yyyy") }
Test Program:
def now = new Date()
println isoFormat(now)
println longFormat(now)
Haskell
import Data.Time
(FormatTime, formatTime, defaultTimeLocale, utcToLocalTime,
getCurrentTimeZone, getCurrentTime)
formats :: FormatTime t => [t -> String]
formats = (formatTime defaultTimeLocale) <$> ["%F", "%A, %B %d, %Y"]
main :: IO ()
main = do
t <- pure utcToLocalTime <*> getCurrentTimeZone <*> getCurrentTime
putStrLn $ unlines (formats <*> pure t)
Sample output:
2017-06-05 Monday, June 05, 2017
HicEst
CHARACTER string*40
WRITE(Text=string, Format='UCCYY-MM-DD') 0 ! string: 2010-03-13
! the U-format to write date and time uses ',' to separate additional output formats
! we therefore use ';' in this example and change it to ',' below:
WRITE(Text=string,Format='UWWWWWWWWW; MM DD; CCYY') 0 ! string = "Saturday ; 03 13; 2010"
READ(Text=string) month ! first numeric value = 3 (no literal month name available)
EDIT(Text='January,February,March,April,May,June,July,August,September,October,November,December', ITeM=month, Parse=cMonth) ! cMonth = "March"
! change now string = "Saturday ; 03 13; 2010" to "Saturday, March 13, 2010":
EDIT(Text=string, Right=' ', Mark1, Right=';', Right=3, Mark2, Delete, Insert=', '//cMonth, Right=';', RePLaceby=',')
END
Icon and Unicon
- Output:
2011-02-01 Tuesday, February 1, 2011
J
Short format using built in formatting:
6!:0 'YYYY-MM-DD'
2010-08-19
Verb to show custom format:
require 'dates system/packages/misc/datefmt.ijs'
days=:;:'Sunday Monday Tuesday Wednesday Thursday Friday Saturday'
fmtDate=: [:((days ;@{~ weekday),', ',ms0) 3 {.]
fmtDate 6!:0 ''
Thursday, August 19, 2010
Java
public static void main(String[] args) {
long millis = System.currentTimeMillis();
System.out.printf("%tF%n", millis);
System.out.printf("%tA, %1$tB %1$td, %1$tY%n", millis);
}
2023-05-10 Wednesday, May 10, 2023
An alternate demonstration
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.text.DateFormatSymbols;
import java.text.DateFormat;
public class Dates{
public static void main(String[] args){
Calendar now = new GregorianCalendar(); //months are 0 indexed, dates are 1 indexed
DateFormatSymbols symbols = new DateFormatSymbols(); //names for our months and weekdays
//plain numbers way
System.out.println(now.get(Calendar.YEAR) + "-" + (now.get(Calendar.MONTH) + 1) + "-" + now.get(Calendar.DATE));
//words way
System.out.print(symbols.getWeekdays()[now.get(Calendar.DAY_OF_WEEK)] + ", ");
System.out.print(symbols.getMonths()[now.get(Calendar.MONTH)] + " ");
System.out.println(now.get(Calendar.DATE) + ", " + now.get(Calendar.YEAR));
}
}
Better: use a library, see http://sourceforge.net/apps/mediawiki/threeten/index.php?title=ThreeTen
Java 8 Date Time API
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
public class Dates
{
public static void main(final String[] args)
{
//using DateTimeFormatter
LocalDate date = LocalDate.now();
DateTimeFormatter dtFormatter = DateTimeFormatter.ofPattern("yyyy MM dd");
System.out.println(dtFormatter.format(date));
}
}
Java Util Date API
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateFormat {
public static void main(String[]args){
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
SimpleDateFormat formatLong = new SimpleDateFormat("EEEE, MMMM dd, yyyy");
System.out.println(format.format(new Date()));
System.out.println(formatLong.format(new Date()));
}
}
JavaScript
JavaScript does not have any built-in strftime
-type functionality.
var now = new Date(),
weekdays = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],
fmt1 = now.getFullYear() + '-' + (1 + now.getMonth()) + '-' + now.getDate(),
fmt2 = weekdays[now.getDay()] + ', ' + months[now.getMonth()] + ' ' + now.getDate() + ', ' + now.getFullYear();
console.log(fmt1);
console.log(fmt2);
2010-1-12 Tuesday, January 12, 2010
Joy
DEFINE weekdays == ["Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday" "Sunday"];
months == ["January" "February" "March" "April" "May" "June" "July" "August"
"September" "October" "November" "December" ].
time localtime [[0 at 'd 4 4 format] ["-"] [1 at 'd 2 2 format] ["-"] [2 at 'd 2 2 format]]
[i] map [putchars] step '\n putch pop.
time localtime [[8 at pred weekdays of] [", "] [1 at pred months of] [" "] [2 at 'd 1 1 format]
[", "] [0 at 'd 4 4 format]] [i] map [putchars] step '\n putch pop.
jq
$ jq -n 'now | (strftime("%Y-%m-%d"), strftime("%A, %B %d, %Y"))'
"2015-07-02"
"Thursday, July 02, 2015"
WARNING: prior to July 2, 2015, there was a bug in jq affecting the display of the "day of week" (wday) and the "day of the year" (yday).
Julia
ts = Dates.today()
println("Today's date is:")
println("\t$ts")
println("\t", Dates.format(ts, "E, U dd, yyyy"))
- Output:
Today's date is: 2018-01-05 Friday, January 05, 2018
Kotlin
// version 1.0.6
import java.util.GregorianCalendar
fun main(args: Array<String>) {
val now = GregorianCalendar()
println("%tF".format(now))
println("%tA, %1\$tB %1\$te, %1\$tY".format(now))
}
- Output:
2017-01-16 Monday, January 16, 2017
langur
writeln string(dt//, "2006-01-02")
writeln string(dt//, "Monday, January 2, 2006")
writeln "{{dt//:dt(2006-01-02)}}"
writeln "{{dt//:dt(Monday, January 2, 2006)}}"
- Output:
2020-03-26 Thursday, March 26, 2020
Lasso
date('11/10/2007')->format('%Q') // 2007-11-10
date('11/10/2007')->format('EEEE, MMMM d, YYYY') //Saturday, November 10, 2007
Liberty BASIC
'Display the current date in the formats of "2007-11-10"
d$=date$("yyyy/mm/dd")
print word$(d$,1,"/")+"-"+word$(d$,2,"/")+"-"+word$(d$,3,"/")
'and "Sunday, November 10, 2007".
day$(0)="Tuesday"
day$(1)="Wednesday"
day$(2)="Thursday"
day$(3)="Friday"
day$(4)="Saturday"
day$(5)="Sunday"
day$(6)="Monday"
theDay = date$("days") mod 7
print day$(theDay);", ";date$()
' month in full
year=val(word$(d$,1,"/"))
month=val(word$(d$,2,"/"))
day=val(word$(d$,3,"/"))
weekDay$="Tuesday Wednesday Thursday Friday Saturday Sunday Monday"
monthLong$="January February March April May June July August September October November December"
print word$(weekDay$,theDay+1);", ";word$(monthLong$,month);" ";day;", ";year
LiveCode
on mouseUp pButtonNumber
put the date into tDate
convert tDate to dateItems
put item 1 of tDate & "-" & item 2 of tDate & "-" & item 3 of tDate & return into tMyFormattedDate
put tMyFormattedDate & the long date
end mouseUp
Logo
A bit of a cheat since Logo has no standard built-in time and date functions, but UCB Logo can call out to the shell, so:
print first shell [date +%F]
print first shell [date +"%A, %B %d, %Y"]
- Output:
2020-09-16 Wednesday, September 16, 2020
Lua
print( os.date( "%Y-%m-%d" ) )
print( os.date( "%A, %B %d, %Y" ) )
M2000 Interpreter
Print str$(today, "yyyy-mm-dd")
Print str$(today, "dddd, mmm, dd, yyyy")
Maple
with(StringTools);
FormatTime("%Y-%m-%d")
FormatTime("%A,%B %d, %y")
Mathematica /Wolfram Language
DateString[{"Year", "-", "Month", "-", "Day"}]
DateString[{"DayName", ", ", "MonthName", " ", "Day", ", ", "Year"}]
MATLAB / Octave
>> datestr(now,'yyyy-mm-dd')
ans =
2010-06-18
>> datestr(now,'dddd, mmmm dd, yyyy')
ans =
Friday, June 18, 2010
min
("YYYY-MM-dd" "dddd, MMMM dd, YYYY") ('timestamp dip tformat puts!) foreach
- Output:
2019-04-02 Tuesday, April 02, 2019
MiniScript
import "dateTime"
print dateTime.now("yyyy-MM-dd")
print dateTime.now("dddd, MMMM d, yyyy")
- Output:
2023-12-28 Thursday, December 28, 2023
mIRC Scripting Language
echo -ag $time(yyyy-mm-dd)
echo -ag $time(dddd $+ $chr(44) mmmm dd $+ $chr(44) yyyy)
MUMPS
Functions starting with 'Z' or '$Z' are implementation specific.
DTZ
WRITE !,"Date format 3: ",$ZDATE($H,3)
WRITE !,"Or ",$ZDATE($H,12),", ",$ZDATE($H,9)
QUIT
MUMPS contains the integer number of days since December 31, 1840 in the first part of the system variable $HOROLOG.
DTM(H)
;You can pass an integer, but the default is to use today's value
SET:$DATA(H)=0 H=$HOROLOG
NEW Y,YR,RD,MC,MO,DA,MN,DN,DOW
SET MN="January,February,March,April,May,June,July,August,September,October,November,December"
SET DN="Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday"
SET MC="31,28,31,30,31,30,31,31,30,31,30,31"
SET Y=+H\365.25 ;This shouldn't be an approximation in production code
SET YR=Y+1841 ;Y is the offset from the epoch in years
SET RD=((+H-(Y*365.25))+1)\1 ;How far are we into the year?
SET $P(MC,",",2)=$S(((YR#4=0)&(YR#100'=0))!((YR#100=0)&(YR#400=0))=0:28,1:29) ;leap year correction
SET MO=1,RE=RD FOR QUIT:RE<=$P(MC,",",MO) SET RE=RE-$P(MC,",",MO),MO=MO+1
SET DA=RE+1
SET DOW=(H#7)+5 ;Fencepost issue - the first piece is 1
;add padding as needed
SET:$L(MO)<2 MO="0"_MO
SET:$L(DA)<2 DA="0"_DA
WRITE !,YR,"-",MO,"-",DA
WRITE !,$P(DN,",",DOW),", ",$P(MN,",",MO)," ",DA,", ",YR
KILL Y,YR,RD,MC,MO,DA,MN,DN,DOW
QUIT
Demos:
USER>D DTM^ROSETTA 2010-06-24 Thursday, June 24, 2010 USER>D DTM^ROSETTA(1234) 1844-05-19 Saturday, May 19, 1844 USER>D DTZ^ROSETTA Date format 3: 2010-06-24 Or Thursday, June 24, 2010
Nanoquery
import Nanoquery.Util
d = new(Date)
println d.getYear() + "-" + d.getMonth() + "-" + d.getDay()
println d.getDayOfWeek() + ", " + d.getMonthName() + " " + d.getDay() + ", " + d.getYear()
Neko
/**
<doc>
<h2>Date format</h2>
<p>Neko uses Int32 to store system date/time values.
And lib C strftime style formatting for converting to string form</p>
</doc>
*/
var date_now = $loader.loadprim("std@date_now", 0)
var date_format = $loader.loadprim("std@date_format", 2)
var now = date_now()
$print(date_format(now, "%F"), "\n")
$print(date_format(now, "%A, %B %d, %Y"), "\n")
- Output:
prompt$ nekoc date-format.neko prompt$ neko date-format.n 2018-11-13 Tuesday, November 13, 2018
NetRexx
import java.text.SimpleDateFormat
say SimpleDateFormat("yyyy-MM-dd").format(Date())
say SimpleDateFormat("EEEE, MMMM dd, yyyy").format(Date())
- Output:
2019-02-10 Sonntag, Februar 10, 2019
NewLISP
; file: date-format.lsp
; url: http://rosettacode.org/wiki/Date_format
; author: oofoe 2012-02-01
; The "now" function returns the current time as a list. A time zone
; offset in minutes can be supplied. The example below is for Eastern
; Standard Time. NewLISP's implicit list indexing is used to extract
; the first three elements of the returned list (year, month and day).
(setq n (now (* -5 60)))
(println "short: " (format "%04d-%02d-%02d" (n 0) (n 1) (n 2)))
; The "date-value" function returns the time in seconds from the epoch
; when used without arguments. The "date" function converts the
; seconds into a time representation specified by the format string at
; the end. The offset argument ("0" in this example) specifies a
; time-zone offset in minutes.
(println "short: " (date (date-value) 0 "%Y-%m-%d"))
; The time formatting is supplied by the underlying C library, so
; there may be differences on certain platforms. Particularly, leading
; zeroes in day numbers can be suppressed with "%-d" on Linux and
; FreeBSD, "%e" on OpenBSD, SunOS/Solaris and Mac OS X. Use "%#d" for
; Windows.
(println "long: " (date (date-value) 0 "%A, %B %#d, %Y"))
; By setting the locale, the date will be displayed appropriately:
(set-locale "japanese")
(println "long: " (date (date-value) 0 "%A, %B %#d, %Y"))
(exit)
- Output:
short: 2012-02-01 short: 2012-02-01 long: Wednesday, February 1, 2012 long: 水曜日, 2月 1, 2012
Nim
import times
var t = now()
echo(t.format("yyyy-MM-dd"))
echo(t.format("dddd',' MMMM d',' yyyy"))
Nu
let now = date now
['%F' '%A, %B %e, %Y'] | each {|fmt| $now | format date $fmt }
Objeck
use IO;
use Time;
bundle Default {
class CurrentDate {
function : Main(args : String[]) ~ Nil {
t := Date->New();
Console->Print(t->GetYear())->Print("-")->Print(t->GetMonth())->Print("-")
->PrintLine(t->GetDay());
Console->Print(t->GetDayName())->Print(", ")->Print(t->GetMonthName())
->Print(" ")->Print(t->GetDay())->Print(", ")
->PrintLine(t->GetYear());
}
}
}
- Output:
2012-5-22 Sunday, May 22, 2012
Objective-C
NSLog(@"%@", [NSDate date]);
NSLog(@"%@", [[NSDate date] descriptionWithCalendarFormat:@"%Y-%m-%d" timeZone:nil locale:nil]);
NSLog(@"%@", [[NSDate date] descriptionWithCalendarFormat:@"%A, %B %d, %Y" timeZone:nil locale:nil]);
NSLog(@"%@", [NSDate date]);
NSDateFormatter *dateFormatter = [[NSDateFormat alloc] init];
[dateFormatter setDateFormat:@"yyyy-MM-dd"];
NSLog(@"%@", [dateFormatter stringFromDate:[NSDate date]]);
[dateFormatter setDateFormat:@"EEEE, MMMM d, yyyy"];
NSLog(@"%@", [dateFormatter stringFromDate:[NSDate date]]);
OCaml
# #load "unix.cma";;
# open Unix;;
# let t = time() ;;
val t : float = 1219997516.
# let gmt = gmtime t ;;
val gmt : Unix.tm =
{tm_sec = 56; tm_min = 11; tm_hour = 8; tm_mday = 29; tm_mon = 7;
tm_year = 108; tm_wday = 5; tm_yday = 241; tm_isdst = false}
# Printf.sprintf "%d-%02d-%02d" (1900 + gmt.tm_year) (1 + gmt.tm_mon) gmt.tm_mday ;;
- : string = "2008-08-29"
let months = [| "January"; "February"; "March"; "April"; "May"; "June";
"July"; "August"; "September"; "October"; "November"; "December" |]
let days = [| "Sunday"; "Monday"; "Tuesday"; (* Sunday is 0 *)
"Wednesday"; "Thursday"; "Friday"; "Saturday" |]
# Printf.sprintf "%s, %s %d, %d"
days.(gmt.tm_wday)
months.(gmt.tm_mon)
gmt.tm_mday
(1900 + gmt.tm_year) ;;
- : string = "Friday, August 29, 2008"
ooRexx
/* REXX */
dats='20071123'
Say date('I',dats,'S')
Say date('W',dats,'S')',' date('M',dats,'S') substr(dats,7,2)',' left(dats,4)
Say date('W',dats,'S')',' date('M',dats,'S') translate('gh, abcd',dats,'abcdefgh')
dati=date('I')
Say dati
Say date('W',dati,'I')',' date('M',dati,'I') translate('ij, abcd',dati,'abcdefghij')
- Output:
2007-11-23
Friday, November 23, 2007 Friday, November 23, 2007 2020-06-05 Friday, June 05, 2020
OxygenBasic
extern lib "kernel32.dll"
'http://msdn.microsoft.com/en-us/library/windows/desktop/ms724950(v=vs.85).aspx
typedef struct _SYSTEMTIME {
WORD wYear;
WORD wMonth;
WORD wDayOfWeek;
WORD wDay;
WORD wHour;
WORD wMinute;
WORD wSecond;
WORD wMilliseconds;
} SYSTEMTIME, *PSYSTEMTIME;
void GetSystemTime(SYSTEMTIME*t);
void GetLocalTime(SYSTEMTIME*t);
end extern
SYSTEMTIME t
'GetSystemTime t 'GMT (Greenwich Mean Time)
GetLocalTime t
String WeekDay[7]={"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"}
String MonthName[12]={"January","February","March","April","May","June","July","August","September","October","November","December"}
String month=str t.wMonth : if len(month)<2 then month="0"+month
String day=str t.wDay : if len(day)<2 then day="0"+day
'
print "" t.wYear "-" month "-" day
print WeekDay[t.wDayOfWeek+1 and 7 ] " " MonthName[t.wMonth and 31] " " t.wDay " " t.wYear
Oz
Getting the current local date is easy, but we have to do the formatting manually.
declare
WeekDays = unit(0:"Sunday" "Monday" "Tuesday" "Wednesday"
"Thursday" "Friday" "Saturday")
Months = unit(0:"January" "February" "March" "April"
"May" "June" "July" "August" "September"
"October" "November" "December")
fun {DateISO Time}
Year = 1900 + Time.year
Month = Time.mon + 1
in
Year#"-"#{Align Month}#"-"#{Align Time.mDay}
end
fun {DateLong Time}
Year = 1900 + Time.year
in
WeekDays.(Time.wDay)#", "#Months.(Time.mon)#" "#Time.mDay#", "#Year
end
fun {Align Num}
if Num < 10 then "0"#Num else Num end
end
in
{System.showInfo {DateISO {OS.localTime}}}
{System.showInfo {DateLong {OS.localTime}}}
Pascal
program dateform;
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;
function m2s(mon: integer): string;
begin
case mon of
1: m2s := 'January';
2: m2s := 'February';
3: m2s := 'March';
4: m2s := 'April';
5: m2s := 'May';
6: m2s := 'June';
7: m2s := 'July';
8: m2s := 'August';
9: m2s := 'September';
10: m2s := 'October';
11: m2s := 'November';
12: m2s := 'December'
end
end;
function d2s(dow: integer): string;
begin
case dow of
0: d2s := 'Sunday';
1: d2s := 'Monday';
2: d2s := 'Tueday';
3: d2s := 'Wednesday';
4: d2s := 'Thursday';
5: d2s := 'Friday';
6: d2s := 'Saturday'
end
end;
var
yr,mo,dy,dow: word;
mname,dname: string;
begin
GetDate(yr,mo,dy,dow);
writeln(yr,'-',lz(mo),'-',lz(dy));
mname := m2s(mo); dname := d2s(dow);
writeln(dname,', ',mname,' ',dy,', ',yr)
end.
- Output:
2010-07-30 Friday, July 30, 2010
PascalABC.NET
begin
var today := DateTime.Now;
Println(today.ToString('yyyy-MM-dd'));
Println($'{today:D}');
end.
- Output:
2024-06-01 Saturday, June 1, 2024
Perl
use POSIX;
print strftime('%Y-%m-%d', 0, 0, 0, 10, 10, 107), "\n";
print strftime('%A, %B %d, %Y', 0, 0, 0, 10, 10, 107), "\n";
- Output:
with locales C
2007-11-10 Saturday, November 10, 2007
- Output:
with locales cs_CZ.UTF-8
2007-11-10 Sobota, listopad 10, 2007
Actual date:
use POSIX;
print strftime('%Y-%m-%d', localtime), "\n";
print strftime('%A, %B %d, %Y', localtime), "\n";
- Output:
with locales C
2008-02-13 Wednesday, February 13, 2008
Phix
with javascript_semantics include builtins\timedate.e ?format_timedate(date(),"YYYY-MM-DD") ?format_timedate(date(),"Dddd, Mmmm d, YYYY")
- Output:
"2015-09-20" "Sunday, September 20, 2015"
PHP
Formatting rules: http://www.php.net/date
<?php
echo date('Y-m-d', time())."\n";
echo date('l, F j, Y', time())."\n";
?>
PicoLisp
(let (Date (date) Lst (date Date))
(prinl (dat$ Date "-")) # 2010-02-19
(prinl # Friday, February 19, 2010
(day Date)
", "
(get *MonFmt (cadr Lst))
" "
(caddr Lst)
", "
(car Lst) ) )
Pike
object cal = Calendar.ISO.Day();
write( cal->format_ymd() +"\n" );
string special = sprintf("%s, %s %d, %d",
cal->week_day_name(),
cal->month_name(),
cal->month_day(),
cal->year_no());
write( special +"\n" );
- Output:
2020-01-03 Friday, January 3, 2020
PL/I
Version 1
df: proc Options(main);
declare day_of_week(7) character (9) varying initial(
'Sunday','Monday','Tuesday','Wednesday',
'Thursday','Friday','Saturday');
declare today character (9);
today = datetime('YYYYMMDD');
put edit(substr(today,1,4),'-',substr(today,5,2),'-',substr(today,7))
(A);
today = datetime('MmmDDYYYY');
put skip edit(day_of_week(weekday(days())),', ') (A);
put edit(substr(today,1,3),' ',substr(today,4,2),', ',
substr(today,6,4))(A);
end;
- Output:
2013-11-02 Saturday, Nov 02, 2013
Version 2
df: proc Options(Main);
declare day_of_week(7) character(9) varying initial(
'Sunday','Monday','Tuesday','Wednesday',
'Thursday','Friday','Saturday');
declare today character(8);
declare month(12) character(10) varying initial(
'January','February','March','April','May','June','July',
'August','September','October','November','December');
Put edit(translate('abcd-ef-gh',datetime('YYYYMMDD'),'abcdefgh'))(a);
today = datetime('MMDDYYYY');
put skip edit(day_of_week(weekday()),', ') (A);
put edit(month(substr(today,1,2)),' ',substr(today,3,2),', ',
substr(today,5,4))(A);
End;
- Output:
2013-11-02 Saturday, November 02, 2013
PowerShell
"{0:yyyy-MM-dd}" -f (Get-Date)
"{0:dddd, MMMM d, yyyy}" -f (Get-Date)
# or
(Get-Date).ToString("yyyy-MM-dd")
(Get-Date).ToString("dddd, MMMM d, yyyy")
Note: The names of months and days follow the currently set locale but otherwise the format is unchanged.
Prolog
display_date :-
get_time(Time),
format_time(atom(Short), '%Y-%M-%d', Time),
format_time(atom(Long), '%A, %B %d, %Y', Time),
format('~w~n~w~n', [Short, Long]).
PureBasic
;Declare Procedures
Declare.s MonthInText()
Declare.s DayInText()
;Output the requested strings
Debug FormatDate("%yyyy-%mm-%dd", Date())
Debug DayInText() + ", " + MonthInText() + FormatDate(" %dd, %yyyy", Date())
;Used procedures
Procedure.s DayInText()
Protected d$
Select DayOfWeek(Date())
Case 1: d$="Monday"
Case 2: d$="Tuesday"
Case 3: d$="Wednesday"
Case 4: d$="Thursday"
Case 5: d$="Friday"
Case 6: d$="Saturday"
Default: d$="Sunday"
EndSelect
ProcedureReturn d$
EndProcedure
Procedure.s MonthInText()
Protected m$
Select Month(Date())
Case 1: m$="January"
Case 2: m$="February"
Case 3: m$="March"
Case 4: m$="April"
Case 5: m$="May"
Case 6: m$="June"
Case 7: m$="July"
Case 8: m$="August"
Case 9: m$="September"
Case 10:m$="October"
Case 11:m$="November"
Default:m$="December"
EndSelect
ProcedureReturn m$
EndProcedure
Python
Formatting rules: http://docs.python.org/lib/module-time.html (strftime)
import datetime
today = datetime.date.today()
# The first requested format is a method of datetime objects:
today.isoformat()
# For full flexibility, use the strftime formatting codes from the link above:
today.strftime("%A, %B %d, %Y")
# This mechanism is integrated into the general string formatting system.
# You can do this with positional arguments referenced by number
"The date is {0:%A, %B %d, %Y}".format(d)
# Or keyword arguments referenced by name
"The date is {date:%A, %B %d, %Y}".format(date=d)
# Since Python 3.6, f-strings allow the value to be inserted inline
f"The date is {d:%A, %B %d, %Y}"
R
strftime is short for "string format time".
now <- Sys.time()
strftime(now, "%Y-%m-%d")
strftime(now, "%A, %B %d, %Y")
Racket
Module racket/date is included within #lang racket However its date to string facilities only provide ISO-8601 (which provides the "2007-11-10" format) but nothing that strictly provides "<Full day name>, <Full month name> ...".
We therefore need to import SRFI/19 "SRFI 19: Time Data Types and Procedures" (it's a standard Racket package).
See: http://srfi.schemers.org/srfi-19/srfi-19.html
#lang racket
(require srfi/19)
;;; The first required format is an ISO-8601 year-month-day format, predefined
;;; as ~1 in date->string
(displayln (date->string (current-date) "~1"))
;;; You should be able to see how each of the components of the following format string
;;; work...
;;; ~d is zero padded day of month:
(displayln (date->string (current-date) "~A, ~B ~d, ~Y"))
;;; ~e is space padded day of month:
(displayln (date->string (current-date) "~A, ~B ~e, ~Y"))
both ~d and ~e satisfy the format required, since the "10" part of that date is 2-digit
- Output:
2013-04-02 Tuesday, April 02, 2013 Tuesday, April 2, 2013
Raku
(formerly Perl 6)
use DateTime::Format;
my $dt = DateTime.now;
say strftime('%Y-%m-%d', $dt);
say strftime('%A, %B %d, %Y', $dt);
The built-in Date and DateTime classes both offer support for the ISO format:
my $d = Date.today;
say $d.yyyy-mm-dd;
They don't include the longer format specified in the task, but you can always roll your own formatter instead of importing the library:
my @months = <January February March April May June July
August September October November December>;
my @days = <Monday Tuesday Wednesday Thursday Friday Saturday Sunday>;
my $us-long = sub ($self) { "{@days[$self.day-of-week - 1]}, {@months[$self.month - 1]} {$self.day}, {$self.year}" };
my $d = Date.today :formatter($us-long);
say $d.yyyy-mm-dd; # still works
say $d; # uses our formatter sub
Raven
time int as today
Short form:
today '%Y-%m-%d' date
Long form:
today '%A, %B %d, %Y' date
REBOL
REBOL [
Title: "Date Formatting"
URL: http://rosettacode.org/wiki/Date_format
]
; REBOL has no built-in pictured output.
zeropad: func [pad n][
n: to-string n
insert/dup n "0" (pad - length? n)
n
]
d02: func [n][zeropad 2 n]
print now ; Native formatting.
print rejoin [now/year "-" d02 now/month "-" d02 now/day]
print rejoin [
pick system/locale/days now/weekday ", "
pick system/locale/months now/month " "
now/day ", " now/year
]
- Output:
6-Dec-2009/10:02:10-5:00 2009-12-06 Sunday, December 6, 2009
RED
Red []
;; zeropad
f2n: func [d] [ if d > 9 [return d ] append copy "0" d ]
d: now/date
print rejoin [d/year "-" f2n d/month "-" f2n d/day]
print rejoin [system/locale/days/(d/weekday) ", " system/locale/months/(d/month) " " f2n d/day ", " d/year]
- Output:
2020-03-25Wednesday, March 25, 2020
REXX
REXX has a number of ways to obtain the various components of the current date (indeed, any date).
It's up to the programmer to choose whatever version of the date BIF that best serves the purpose.
idiomatic version
/*REXX pgm shows current date: yyyy-mm-dd & Dayofweek, Month dd, yyyy*/
x = date('S') /*get current date as yyyymmdd */
yyyy = left(x,4) /*pick off year (4 digs).*/
dd = right(x,2) /*pick off day-of-month (2 digs).*/
mm = substr(x,5,2) /*pick off month number (2 digs).*/
say yyyy'-'mm"-"dd /*yyyy-mm-dd with leading zeroes.*/
weekday = date('W') /*dayofweek (Monday or somesuch).*/
month = date('M') /*Month (August or somesuch).*/
zdd = dd+0 /*remove leading zero from DD */
say weekday',' month zdd"," yyyy /*format date as: Month dd, yyyy*/
/*stick a fork in it, we're done.*/
- Output:
2010-09-01 Wednesday, September 1, 2010
compact version
/*REXX pgm shows current date: yyyy-mm-dd & Dayofweek, Month dd, yyyy*/
/* ╔══════════════════════════════════════════════════════════════════╗
║ function returns a specific example ║
║ ─────────── ─────────────────────────── ──────────────────── ║
║ date() dd mon yyyy 3 Jun 2009 ║
║ date('N') (same as above) ║
║ date('B') days since Jan 1, year 1 735382 ║
║ date('C') days since Jan 1 this century 5264 ║
║ date('D') days since Jan 1, this yr 154 ║
║ date('E') dd/mm/yy 03/06/09 ║
║ date('I') yyyy-mm-dd 2009-03-06 ║
║ date('J') yyddd 2009154 ║
║ date('M') month name June ║
║ date('O') yy/mm/dd 09/03/06 ║
║ date('S') yyyyddmm 20090603 ║
║ date('T') seconds since Jan 1st, 1970 1401483686 ║
║ date('U') mm/dd/yy 03/06/09 ║
║ date('W') day─of─the─week Wednesday ║
║ ─────────── ─────────────────────────── ──────────────────── ║
║ ║
║ Note: not all of the above are supported by all REXX versions. ║
╚══════════════════════════════════════════════════════════════════╝ */
parse value date('S') with yyyy 5 mm 7 dd /*get various pieces of date*/
say yyyy'-'mm"-"dd /*yyyy-mm-dd with leading zeroes.*/
say date('W')"," date('M') word(date(), 1)"," yyyy
/* [↑] dayofweek Month dd, yyyy*/
/*stick a fork in it, we're done.*/
output would be the same as the 1st version.
modern version
This version can be used with those REXXes that support the I (ISO) parameter for the date BIF.
/*REXX pgm shows current date: yyyy-mm-dd & Dayofweek, Month dd, yyyy*/
say date('I') /*yyyy-mm-dd with leading zeroes.*/
say date('W')"," date('M') word(date(), 1)"," left(date('S'),4)
/* [↑] dayofweek Month dd, yyyy*/
/*stick a fork in it, we're done.*/
output would be the same as the 1st version.
Ring
dateStr = date()
date1 = timelist()[19] + "-" + timelist()[10] + "-" + timelist()[6]
date2 = timelist()[2] + ", " + timelist()[4] + " " + timelist()[6] + ", " + timelist()[19] + nl
? dateStr
? date1
? date2
/*
timelist() ---> List contains the time and date information.
Index Value
----------------------------
1 - abbreviated weekday name
2 - full weekday name
3 - abbreviated month name
4 - full month name
5 - Date & Time
6 - Day of the month
7 - Hour (24)
8 - Hour (12)
9 - Day of the year
10 - Month of the year
11 - Minutes after hour
12 - AM or PM
13 - Seconds after the hour
14 - Week of the year (sun-sat)
15 - day of the week
16 - date
17 - time
18 - year of the century
19 - year
20 - time zone
21 - percent sign
*/
- Output:
19/07/2020 2020-07-19 Sunday, July 19, 2020
RPL
RPL can return the date as a floating point number (format dd.mmyyyy) and can convert it (along with the time) as a string (format "DAY dd.mm.yy hh.mm.ss") To solve the task, some formatting is then needed.
≪ DATE DUP 1000000 * 10000 MOD "-" + OVER FP 100 * IP + "-" + SWAP IP + ≫ 'DTSHORT' STO ≪ { "Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday" "Sunday" } { "MON" "TUE" "WED" "THU" "FRI" "SAT" "SUN" } DATE TIME TSTR 1 3 SUB POS GET ", " + { "January" "February" "March" "April" "May" "June" "July" "August" "September" "October" "November" "December"} DATE FP 100 * IP GET + " " + OVER IP + ", " + DATE 1000000 * 10000 MOD + ≫ 'DTLONG' STO
- Output:
2: "2023-8-17" 1: "Thursday, August 17, 2023"
Ruby
Formatting rules: Time#strftime
puts Time.now
puts Time.now.strftime('%Y-%m-%d')
puts Time.now.strftime('%F') # same as %Y-%m-%d (ISO 8601 date formats)
puts Time.now.strftime('%A, %B %d, %Y')
- Output:
2015-02-08 10:48:45 +0900 2015-02-08 2015-02-08 Sunday, February 08, 2015
Run BASIC
'Display the current date in the formats of "2007-11-10" and "Sunday, November 10, 2007".
print date$("yyyy-mm-dd")
print date$("dddd");", "; 'return full day of the week (eg. Wednesday
print date$("mmmm");" "; 'return full month name (eg. March)
print date$("dd, yyyy") 'return day, year
- Output:
2012-03-16 Friday, March 16, 2012
Rust
Using chrono 0.4.6
fn main() {
let now = chrono::Utc::now();
println!("{}", now.format("%Y-%m-%d"));
println!("{}", now.format("%A, %B %d, %Y"));
}
Scala
import java.util.Date
val now=new Date()
println("%tF".format(now))
println("%1$tA, %1$tB %1$td, %1$tY".format(now))
- Output:
2023-04-17 Monday, April 17, 2023
Scheme
(define short-date
(lambda (lt)
(strftime "%Y-%m-%d" (localtime lt))))
(define long-date
(lambda (lt)
(strftime "%A, %B %d, %Y" (localtime lt))))
(define main
(lambda (args)
;; Current date
(let ((dt (car (gettimeofday))))
;; Short style
(display (short-date dt))(newline)
;; Long style
(display (long-date dt))(newline))))
Seed7
$ include "seed7_05.s7i";
include "time.s7i";
const proc: main is func
local
const array string: months is [] ("January", "February", "March", "April", "May", "June",
"July", "August", "September", "October", "November", "December");
const array string: days is [] ("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday");
var time: now is time.value;
begin
now := time(NOW);
writeln(strDate(now));
writeln(days[dayOfWeek(now)] <& ", " <& months[now.month] <& " " <& now.day <& ", " <& now.year);
end func;
SenseTalk
put formattedTime( "[year]-[month]-[day]", the date)
put formattedTime( "[weekday], [month name] [day], [year]", the date)
- Output:
2019-12-18 Wednesday, December 18, 2019
Shiny
say time.format 'Y-m-d' time.now
say time.format 'l, F j, Y' time.now
Sidef
var time = Time.local;
say time.ctime;
say time.strftime("%Y-%m-%d");
say time.strftime("%A, %B %d, %Y");
- Output:
Fri Oct 17 12:57:02 2014 2014-10-17 Friday, October 17, 2014
Smalltalk
In Smalltalk, one sends a printFormat message to a Date object with year, month, and day. For other date strings, one must construct the date string from the parts of a Date object. Of course, you'd probably want to make a method for doing so.
| d |
d := Date today.
d printFormat: #(3 2 1 $- 1 1 2).
(d weekday asString), ', ', (d monthName), ' ', (d dayOfMonth asString), ', ', (d year asString)
d := Date today.
d printOn:Stdout format:'%y-%m-%d'. Stdout cr.
d printOn:Stdout format:'%(DayName), %(MonthName) %d, %y' language:#en. Stdout cr.
d printOn:Stdout format:'%(DayName), %(MonthName) %d, %y' language:#de. Stdout cr.
d printOn:Stdout format:'%(DayName), %(MonthName) %d, %y' language:#fr. Stdout cr.
- Output:
2020-12-17 Thursday, December 17, 2020 Donnerstag, Dezember 17, 2020 Vendredi, Décembre 17, 2020
SparForte
As a structured script. Does not use l10n package.
#!/usr/local/bin/spar
pragma annotate( summary, "dateformat")
@( description, "Display the current date in the formats of '2007-11-10' " )
@( description, "and 'Sunday, November 10, 2007'." )
@( see_also, "http://rosettacode.org/wiki/Date_format" )
@( "Ken O. Burtch" );
pragma license( unrestricted );
pragma restriction( no_external_commands );
procedure dateformat is
function Month_Image (Month : calendar.month_number) return string is
begin
case Month is
when 1 => return "January";
when 2 => return "February";
when 3 => return "March";
when 4 => return "April";
when 5 => return "May";
when 6 => return "June";
when 7 => return "July";
when 8 => return "August";
when 9 => return "September";
when 10 => return "October";
when 11 => return "November";
when others => return "December";
end case;
end Month_Image;
function Day_Image (Day : integer) return string is
begin
case Day is
when 0 => return "Monday";
when 1 => return "Tuesday";
when 2 => return "Wednesday";
when 3 => return "Thursday";
when 4 => return "Friday";
when 5 => return "Saturday";
when others => return "Sunday";
end case;
end Day_Image;
Today : constant calendar.time := calendar.clock;
begin
--put_line(
--Put_Line (Image (Today) (1..10));
put( calendar.year( Today ), "9999" ) @( "-" )
@( calendar.month( Today ), "99" ) @( "-" )
@( calendar.day( Today ), "99" );
new_line;
put_line(
Day_Image( calendar.day_of_week( Today ) ) & ", " &
Month_Image( calendar.month( Today ) ) &
strings.image( calendar.day( Today ) ) & "," &
strings.image( calendar.year( Today ) ) );
end dateformat;
SQL
select to_char(sysdate,'YYYY-MM-DD') date_fmt_1 from dual;
select to_char(sysdate,'fmDay, Month DD, YYYY') date_fmt_2 from dual;
SQL> DATE_FMT_1 ---------- 2016-12-12 SQL> SQL> DATE_FMT_2 -------------------------------------------------------------------------------- Monday, December 12, 2016
Standard ML
Formatting rules: http://www.standardml.org/Basis/date.html#SIG:DATE.fmt:VAL
print (Date.fmt "%Y-%m-%d" (Date.fromTimeLocal (Time.now ())) ^ "\n");
print (Date.fmt "%A, %B %d, %Y" (Date.fromTimeLocal (Time.now ())) ^ "\n");
- Output:
2008-02-13 Wednesday, February 13, 2008
Stata
Stata has many ways to format dates, see Datetime display formats in the documentation.
display %tdCCYY-NN-DD td($S_DATE)
display %tdDayname,_Month_dd,_CCYY td($S_DATE)
Suneido
Date().Format('yyyy-MM-dd') --> "2010-03-16"
Date().LongDate() --> "Tuesday, March 16, 2010"
Swift
import Foundation
extension String {
func toStandardDateWithDateFormat(format: String) -> String {
let dateFormatter = NSDateFormatter()
dateFormatter.dateFormat = format
dateFormatter.dateStyle = .LongStyle
return dateFormatter.stringFromDate(dateFormatter.dateFromString(self)!)
}
}
let date = "2015-08-28".toStandardDateWithDateFormat("yyyy-MM-dd")
- Output:
2015ꈎ8ꆪ28ꑍ(In Sichuan Yi Language Environment)
Tcl
set now [clock seconds]
puts [clock format $now -format "%Y-%m-%d"]
puts [clock format $now -format "%A, %B %d, %Y"]
Terraform
locals {
today = timestamp()
}
output "iso" {
value = formatdate("YYYY-MM-DD", local.today)
}
output "us-long" {
value = formatdate("EEEE, MMMM D, YYYY", local.today)
}
- Output:
Apply complete! Resources: 0 added, 0 changed, 0 destroyed. Outputs: iso = 2020-09-16 us-long = Wednesday, September 16, 2020
TUSCRIPT
$$ MODE TUSCRIPT
SET dayofweek = DATE (today,day,month,year,number)
SET months=*
DATA January
DATA Februari
DATA March
DATA April
DATA Mai
DATA June
DATA July
DATA August
DATA September
DATA October
DATA November
DATA December
SET days="Monday'Tuesday'Wendsday'Thursday'Fryday'Saturday'Sonday"
SET nameofday =SELECT (days,#dayofweek)
SET nameofmonth=SELECT (months,#month)
SET format1=JOIN (year,"-",month,day)
SET format2=CONCAT (nameofday,", ",nameofmonth," ",day, ", ",year)
PRINT format1
PRINT format2
- Output:
2011-1-5 Wendsday, January 5, 2011
UNIX Shell
date +"%Y-%m-%d"
date +"%A, %B %d, %Y"
On a new enough system %F
is equivalent to %Y-%m-%d
date +"%F"
Ursa
Cygnus/X Ursa can import and call Java classes.
cygnus/x ursa v0.78 (default, release 0)
[Oracle Corporation JVM 1.8.0_51 on Mac OS X 10.10.5 x86_64]
> import "java.util.Date"
> import "java.text.SimpleDateFormat"
> decl java.text.SimpleDateFormat sdf
> sdf.applyPattern "yyyy-MM-dd"
> decl java.util.Date d
> out (sdf.format d) endl console
2016-07-23
> sdf.applyPattern "EEEE, MMMM dd, yyyy"
> out (sdf.format d) endl console
Saturday, July 23, 2016
> _
Ursala
The method is to transform a date in standard format returned by the library function, now.
#import std
#import cli
months = ~&p/block3'JanFebMarAprMayJunJulAugSepOctNovDec' block2'010203040506070809101112'
completion =
-:~& ~&pllrTXS/block3'SunMonTueWedThuFriSat'--(~&lS months) -- (
--','* sep`, 'day,day,sday,nesday,rsday,day,urday',
sep`, 'uary,ruary,ch,il,,e,y,ust,tember,ober,ember,ember')
text_form = sep` ; mat` + completion*+ <.~&hy,~&tth,--','@th,~&ttth>
numeric_form = sep` ; mat`-+ <.~&ttth,@tth -: months,~&th>
#show+
main = <.text_form,numeric_form> now0
- Output:
Wednesday, June 24, 2009 2009-06-24
VB-DOS
OPTION EXPLICIT
' Months
DATA "January", "February", "March", "April", "May", "June", "July"
DATA "August", "September", "October", "November", "December"
' Days of week
DATA "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
' Var
DIM dDate AS DOUBLE, sMonth(1 TO 12) AS STRING, sDay(1 TO 7) AS STRING
DIM i AS INTEGER
' Read Names of months
FOR i = 1 TO 12
READ sMonth(i)
NEXT i
' Read Names of days
FOR i = 1 TO 7
READ sDay(i)
NEXT i
' Assign current date to a variable
dDate = NOW
CLS
PRINT "Rosettacode: Display the current date formatted."
PRINT
PRINT "Today's date: "; FORMAT$(dDate, "ddddd")
PRINT
PRINT "Use of values in the lists."
PRINT "Today is "; sDay(WEEKDAY(dDate)); ", "; sMonth(MONTH(dDate)); " "; FORMAT$(DAY(dDate)); ", "; FORMAT$(YEAR(dDate)); "."
PRINT
PRINT "Use of just the FORMAT$() function."
PRINT "Today is "; FORMAT$(dDate, "dddd, mmmm d, yyyy"); "."
END
VBA
Function DateFormats()
Debug.Print Format(Date, "yyyy-mm-dd")
Debug.Print Format(Date, "dddd, mmmm dd yyyy")
End Function
VBScript
'YYYY-MM-DD format
WScript.StdOut.WriteLine Year(Date) & "-" & Right("0" & Month(Date),2) & "-" & Right("0" & Day(Date),2)
'Weekday_Name, Month_Name DD, YYYY format
WScript.StdOut.WriteLine FormatDateTime(Now,1)
- Output:
2015-08-31 Monday, August 31, 2015
Vedit macro language
Display current date in format "2007-11-10":
Date(REVERSE+NOMSG+VALUE, '-')
Display current date in format "Sunday, November 10, 2007" (Requires VEDIT 6.2):
// Get todays date into #1, #2, #3 and #7
#1 = Date_Day
#2 = Date_Month
#3 = Date_Year
#7 = JDate() % 7 // #7 = weekday
// Convert weekday number (in #7) into word in T-reg 1
if (#7==0) { RS(1,"Sunday") }
if (#7==1) { RS(1,"Monday") }
if (#7==2) { RS(1,"Tuesday") }
if (#7==3) { RS(1,"Wednesday") }
if (#7==4) { RS(1,"Thursday") }
if (#7==5) { RS(1,"Friday") }
if (#7==6) { RS(1,"Saturday") }
// Convert month number (in #2) into word in T-reg 2
if (#2==1) { RS(2,"January") }
if (#2==2) { RS(2,"February") }
if (#2==3) { RS(2,"March") }
if (#2==4) { RS(2,"April") }
if (#2==5) { RS(2,"May") }
if (#2==6) { RS(2,"June") }
if (#2==7) { RS(2,"July") }
if (#2==8) { RS(2,"August") }
if (#2==9) { RS(2,"September") }
if (#2==10) { RS(2,"October") }
if (#2==11) { RS(2,"November") }
if (#2==12) { RS(2,"December") }
// Display the date string
RT(1) M(", ") RT(2) M(" ") NT(#1, LEFT+NOCR) M(",") NT(#3)
To insert the date string into edit buffer instead of displaying it, replace the last line with this:
RI(1) IT(", ") RI(2) IT(" ") NI(#1, LEFT+NOCR) IT(",") NI(#3)
Vim Script
See `:help strftime` - this function uses the C strftime() arguments' format.
echo strftime("%Y-%m-%d")
echo strftime("%A, %B %d, %Y")
V (Vlang)
import time
fn main() {
println(time.now().custom_format("YYYY-MM-DD"))
println(time.now().custom_format("dddd, MMMM D, YYYY"))
}
- Output:
2011-12-02 Friday, December 2, 2011
Wren
Unless it is embedded in a host application, Wren currently has no direct way to obtain the current date. We therefore assume this is passed in by the user as a command line parameter.
import "os" for Process
import "./date" for Date
var args = Process.arguments
if (args.count != 1) {
Fiber.abort("Please pass just the current date in yyyy-mm-dd format.")
}
var current = Date.parse(args[0])
System.print(current.format(Date.isoDate))
System.print(current.format("dddd|, |mmmm| |d|, |yyyy"))
- Output:
$ wren date_format.wren 2020-06-05 2020-06-05 Friday, June 5, 2020
XPL0
include c:\cxpl\codes;
int CpuReg, Year, Month, Day, DName, MName, WDay;
[CpuReg:= GetReg; \access CPU registers
CpuReg(0):= $2A00; \DOS system call
SoftInt($21);
Year:= CpuReg(2);
Month:= CpuReg(3) >> 8;
Day:= CpuReg(3) & $FF;
WDay:= CpuReg(0) & $FF;
IntOut(0, Year); ChOut(0, ^-);
if Month<10 then ChOut(0, ^0); IntOut(0, Month); ChOut(0, ^-);
if Day<10 then ChOut(0, ^0); IntOut(0, Day); CrLf(0);
DName:= ["Sunday", "Monday", "Tuesday", "Wednesday",
"Thursday", "Friday", "Saturday"];
MName:= [0, "January", "February", "March", "April", "May", "June", "July",
"August", "September", "October", "November", "December"];
Text(0, DName(WDay)); Text(0, ", "); Text(0, MName(Month)); Text(0, " ");
IntOut(0, Day); Text(0, ", "); IntOut(0, Year); CrLf(0);
]
- Output:
2012-11-20 Tuesday, November 20, 2012
Yabasic
dim n$(1)
n = token(date$, n$(), "-")
print n$(4), "-", n$(2), "-", n$(3)
print nDay$(n$(5)), ", ", nMonth$(n$(6)), " ", n$(3), ", ", n$(4)
sub nDay$(n$)
switch n$
case "Mon": case "Fri": case "Sun": break
case "Tue": n$ = n$ + "s" : break
case "Wed": n$ = n$ + "nes" : break
case "Thu": n$ = n$ + "rs" : break
case "Sat": n$ = n$ + "ur" : break
default: n$ = "none" : break
end switch
return n$ + "day"
end sub
sub nMonth$(n$)
local month$(1), n
n = token("January, February, March, April, May, June, July, August, September, October, November, December", month$(), ", ")
n = instr("JanFebMarAprMayJunJulAugSepOctNovDec", n$)
return month$(int(n/3) + 1)
end sub
zkl
"%d-%02d-%02d".fmt(Time.Clock.localTime.xplode()).println()
//--> "2014-02-28" (ISO format)
Not quite but close. Even though localTime returns a 7 tuple (and xplode pushes all 7 as call args), fmt only eats what it needs.
Time.Date.prettyDay(Time.Clock.localTime.xplode())
//--> "Friday, the 28th of February 2014"
y,m,d:=Time.Clock.localTime; D:=Time.Date;
"%s, %s %d, %d".fmt(D.dayName(D.weekDay(y,m,d)),
D.monthName(m), d,y)
//-->"Friday, February 28, 2014"
zonnon
module Main;
import System;
var
now: System.DateTime;
begin
now := System.DateTime.Now;
System.Console.WriteLine(now.ToString("yyyy-MM-dd");
System.Console.WriteLine("{0}, {1}",now.DayOfWeek,now.ToString("MMMM dd, yyyy"));
end Main.
- Output:
2017-12-05 Tuesday, diciembre 05, 2017
- Programming Tasks
- Text processing
- Clarified and Needing Review
- 11l
- 68000 Assembly
- 8th
- AArch64 Assembly
- ABAP
- Action!
- Ada
- ALGOL 68
- Apex
- AppleScript
- ARM Assembly
- Arturo
- AutoHotkey
- AutoIt
- AWK
- BaCon
- BASIC
- Batch File
- BBC BASIC
- Beads
- C
- C sharp
- C++
- Clojure
- COBOL
- CoffeeScript
- ColdFusion
- Common Lisp
- Component Pascal
- Crystal
- D
- Tango
- Delphi
- Diego
- EasyLang
- Ed
- EGL
- Elixir
- Emacs Lisp
- Erlang
- Euphoria
- F Sharp
- Factor
- Fantom
- Forth
- Fortran
- FreeBASIC
- Free Pascal
- Frink
- FunL
- FutureBasic
- Gambas
- Go
- Groovy
- Haskell
- HicEst
- Icon
- Unicon
- J
- Java
- JavaScript
- Joy
- Jq
- Julia
- Kotlin
- Langur
- Lasso
- Liberty BASIC
- LiveCode
- Logo
- Lua
- M2000 Interpreter
- Maple
- Mathematica
- Wolfram Language
- MATLAB
- Octave
- Min
- MiniScript
- MIRC Scripting Language
- MUMPS
- Nanoquery
- Neko
- NetRexx
- NewLISP
- Nim
- Nu
- Objeck
- Objective-C
- OCaml
- OoRexx
- OxygenBasic
- Oz
- Pascal
- PascalABC.NET
- Perl
- POSIX
- Phix
- Phix/basics
- PHP
- PicoLisp
- Pike
- PL/I
- PowerShell
- Prolog
- PureBasic
- Python
- R
- Racket
- Raku
- DateTime::Format
- Raven
- REBOL
- RED
- REXX
- Ring
- RPL
- Ruby
- Run BASIC
- Rust
- Scala
- Scheme
- Seed7
- SenseTalk
- Shiny
- Sidef
- Smalltalk
- SparForte
- SQL
- Standard ML
- Stata
- Suneido
- Swift
- Tcl
- Terraform
- TUSCRIPT
- UNIX Shell
- Ursa
- Ursala
- VB-DOS
- VBA
- VBScript
- Vedit macro language
- Vim Script
- V (Vlang)
- Wren
- Wren-date
- XPL0
- Yabasic
- Zkl
- Zonnon
- ML/I/Omit
- PARI/GP/Omit
- Date and time
- Pages with too many expensive parser function calls