Date format

From Rosetta Code
Revision as of 16:51, 2 May 2022 by Depperm (talk | contribs)
Task
Date format
You are encouraged to solve this task according to the task description, using any language you may know.
This task has been clarified. Its programming examples are in need of review to ensure that they still fit the requirements of the task.


Task

Display the   current date   in the formats of:

  •   2007-11-23     and
  •   Friday, November 23, 2007



11l

<lang 11l>print(Time().format(‘YYYY-MM-DD’)) print(Time().strftime(‘%A, %B %e, %Y’))</lang>

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


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

Output can be seen here, but is also reproduced below:

2021-09-19
 Sunday, September 19, 2021

8th

<lang forth> d:new "%Y-%M-%D" over d:format . cr "%W, %N %D, %Y" over d:format . cr bye </lang>

AArch64 Assembly

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

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

ABAP

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

Action!

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

Output:

Screenshot from Atari 8-bit computer

2021-09-01
Wednesday, September 1, 2021

Ada

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

Output:
2008-10-03
Friday, October 3, 2008

ALGOL 68

Works with: ALGOL 68 version Standard - using the a68g standard library
Works with: ALGOL 68G version Any - tested with release mk15-0.8b.fc9.i386

Note: the format can be used for both printing and reading date data.

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

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$))</lang>
Output:
2009-04-08
Wednesday, April 8, 2009
Wed Apr  8 18:04:02 MSD 2009

Apex

<lang java> 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" </lang>

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.

<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 set longFormat to (w as text) & (", " & m) & (space & d) & (", " & y)

return (shortFormat & linefeed & longFormat)</lang>

Output:

<lang applescript>"2020-10-28 Wednesday, October 28, 2020"</lang>

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.


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

Output:
2020-09-11
Friday, September 11, 2020

Functional

Or, emphasising productivity and functional composition:

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

Output:
2020-09-11
Friday, September 11, 2020

ARM Assembly

Works with: as version Raspberry Pi

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

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

<lang rebol>currentTime: now

print to :string.format: "YYYY-MM-dd" currentTime print to :string.format: "dddd, MMMM dd, YYYY" currentTime</lang>

Output:
2021-03-11
Thursday, March 11, 2021

AutoHotkey

<lang autohotkey>FormatTime, Date1, , yyyy-MM-dd ; "2007-11-10" FormatTime, Date2, , LongDate  ; "Sunday, November 10, 2007" MsgBox %Date1% `n %Date2%</lang>

AutoIt

This solution uses the locale settings for names of days and months. <lang AutoIt>

  1. 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 </lang>

Output:
2007-11-10
Samstag, November 10, 2007

--BugFix (talk) 16:24, 17 November 2013 (UTC)

AWK

Works with: Gawk

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

BaCon

<lang freebasic>' 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"</lang>

Output:
prompt$ ./date-format
2017-02-17
Friday, February 17, 2017

BASIC

Works with: FreeBASIC

<lang freebasic>#include "vbcompat.bi"

DIM today As Double = Now()

PRINT Format(today, "yyyy-mm-dd") PRINT Format(today, "dddd, mmmm d, yyyy")</lang>

Batch File

<lang dos> @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 </lang>

Output:
2017-04-16
Sunday,  16, 2017

BBC BASIC

<lang bbcbasic> 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$</lang>

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

<lang beads>beads 1 program 'Date format'

calc main_init log time_to_str('[iso date]') log time_to_str('[sunday], [january] [day2], [year]')</lang>

Output:
2021-03-11
Thursday, March 11, 2021

C

<lang c>#include <stdlib.h>

  1. include <stdio.h>
  2. include <time.h>
  3. 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;

}</lang>

Output:
2009-5-13
Wednesday, May 13, 2009
Wednesday, May 13, 2009

C#

<lang csharp>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"));
       }
   }

}</lang>

C++

<lang cpp>// Display the current date in the formats of "2007-11-10" // and "Sunday, November 10, 2007".

  1. include <vector>
  2. include <string>
  3. include <iostream>
  4. 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, &ltime);
   }
   
   /** 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, &ltime);
       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;

}</lang>

Output:
2009-05-14
Thursday, May 14, 2009

Clojure

<lang lisp>(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)))</lang>
Output:
2009-12-06
Sunday, December 06, 2009

COBOL

Works with: OpenCOBOL

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

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

</lang>

Portable version

<lang coffeescript>

  1. JS does not have extensive formatting support out of the box. This code shows
  2. 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) </lang>

Output:
> coffee date_format.coffee 
2012-01-14
Saturday, January 14, 2012

ColdFusion

<lang cfm><cfoutput>

   #dateFormat(Now(), "YYYY-MM-DD")#
#dateFormat(Now(), "DDDD, MMMM DD, YYYY")#

</cfoutput></lang>

Common Lisp

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

With the local-time library:

<lang lisp> (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"

</lang>

Component Pascal

BlackBox Component Builder <lang oberon2> 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. </lang> 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

Works with: Crystal version 0.33

<lang crystal>require "time"

time = Time.local puts time.to_s("%Y-%m-%d") puts time.to_s("%A, %B %d, %Y") </lang>

D

Works with: D version DMD 1.026
Library: Tango

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

}</lang>

Output:
2007-11-10
Saturday, November 10, 2007
Friday, February 1, 2008

Delphi

<lang Delphi>ShowMessage(FormatDateTime('yyyy-mm-dd', Now) +#13#10+ FormatDateTime('dddd, mmmm dd, yyyy', Now));</lang>

Output:
2022-02-16
Wednesday, February 16, 2022
Redirecting to 

EGL

<lang 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")); </lang>

Output:
2012-09-26
Wednesday, September 26, 2012

Elixir

Translation of: Erlang
Works with: Elixir version 1.4

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

Output:
2017-02-26
Sunday, February 26, 2017
2007-11-10
Saturday, November 10, 2007

Emacs Lisp

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

%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

<lang 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)]).</lang>

Euphoria

<lang 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]})</lang>

F#

"F# Interactive" session: <lang fsharp>> open System;; > Console.WriteLine( DateTime.Now.ToString("yyyy-MM-dd") );; 2010-08-13 > Console.WriteLine( "{0:D}", DateTime.Now );; Friday, August 13, 2010</lang>

Factor

<lang factor>USING: formatting calendar io ;

now "%Y-%m-%d" strftime print now "%A, %B %d, %Y" strftime print</lang>

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

<lang fantom> fansh> Date.today.toLocale("YYYY-MM-DD") 2011-02-24 fansh> Date.today.toLocale("WWWW, MMMM DD, YYYY") Thursday, February 24, 2011 </lang>

Forth

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

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.

<LANG FORTH>\ 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 ##.  ','  ####.  ;</LANG>


Test at the Forth Console <LANG FORTH> 5 7 2018 Y-M-D. 2018-07-05 ok

 ok

5 7 2018 LONG.DATE Thursday, July 05, 2018 ok </LANG>

Fortran

Works with: Fortran version 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 <lang fortran>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</lang>

Output:
2008-12-14
Sunday, December 14, 2008

FreeBASIC

<lang freebasic>' FB 1.05.0 Win64

  1. 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</lang>

Output:
This example was created on : 2016-10-02
In other words on : Sunday, October 2, 2016

Free Pascal

<lang Pascal>program Format_Date_Time; uses

 SysUtils;

begin

 WriteLn(FormatDateTime('yyyy-mm-dd', Now) +#13#10+ FormatDateTime('dddd, mmmm dd, yyyy', Now));

end.

   </lang>
Output:
2022-02-16
Wednesday, February 16, 2022

Frink

<lang frink> println[now[] -> ### yyyy-MM-dd ###] println[now[] -> ### EEEE, MMMM d, yyyy ###] </lang>

FunL

<lang funl>println( format('%tF', $date) ) println( format('%1$tA, %1$tB %1$td, %1$tY', $date) )</lang>

Gambas

You can run this code. Copy the code, click this link, paste it in and press 'Run !' <lang gambas>Public Sub Main()

Print Format(Now, "yyyy - mm - dd") Print Format(Now, "dddd, mmmm dd, yyyy")

End</lang> 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 <lang go>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"))

}</lang>

Output:
2011-12-02
Friday, December 2, 2011

Groovy

Solution: <lang groovy>def isoFormat = { date -> date.format("yyyy-MM-dd") } def longFormat = { date -> date.format("EEEE, MMMM dd, yyyy") }</lang>

Test Program: <lang groovy>def now = new Date() println isoFormat(now) println longFormat(now)</lang>

Haskell

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

Sample output:

2017-06-05
Monday, June 05, 2017

HicEst

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

Icon and Unicon

<lang Icon>procedure main() write(map(&date,"/","-")) write(&dateline ? tab(find(&date[1:5])+4)) end</lang>

Output:
2011-02-01
Tuesday, February 1, 2011

J

Short format using built in formatting: <lang j> 6!:0 'YYYY-MM-DD' 2010-08-19</lang>

Verb to show custom format: <lang j>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</lang>

Java

<lang java> 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));
}

} </lang> Better: use a library, see http://sourceforge.net/apps/mediawiki/threeten/index.php?title=ThreeTen

Java 8 Date Time API

<lang java> 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));
}

} </lang>

Java Util Date API

<lang java> 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()));
   }

} </lang>

JavaScript

JavaScript does not have any built-in strftime-type functionality. <lang javascript>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);</lang>

2010-1-12
Tuesday, January 12, 2010

Joy

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

jq

Works with: jq version with strftime

<lang sh>$ jq -n 'now | (strftime("%Y-%m-%d"), strftime("%A, %B %d, %Y"))' "2015-07-02" "Thursday, July 02, 2015"</lang>

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

Works with: Julia version 0.6

<lang julia>ts = Dates.today()

println("Today's date is:") println("\t$ts") println("\t", Dates.format(ts, "E, U dd, yyyy"))</lang>

Output:
Today's date is:
	2018-01-05
	Friday, January 05, 2018

Kotlin

<lang scala>// 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))

}</lang>

Output:
2017-01-16
Monday, January 16, 2017

langur

Works with: langur version 0.10.1

<lang langur>var .now = dt// var .format1 = "2006-01-02" var .format2 = "Monday, January 2, 2006" writeln $"\.now:dt.format1;" writeln $"\.now:dt.format2;"</lang>

Works with: langur version 0.9.3

<lang langur>var .now = dt// writeln $"\.now:dt(2006-01-02);" writeln $"\.now:dt(Monday, January 2, 2006);"</lang>

Works with: langur version 0.9

<lang langur>writeln toString dt//, "2006-01-02" writeln toString dt//, "Monday, January 2, 2006"</lang>

Output:
2020-03-26
Thursday, March 26, 2020

Langur is using the Go time package, and using its formatting method for output. It expects the following parts in a format string.

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

Lasso

<lang Lasso> date('11/10/2007')->format('%Q') // 2007-11-10 date('11/10/2007')->format('EEEE, MMMM d, YYYY') //Saturday, November 10, 2007

</lang>

Liberty BASIC

<lang lb>'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</lang>


LiveCode

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

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: <lang logo> print first shell [date +%F] print first shell [date +"%A, %B %d, %Y"] </lang>

Output:
2020-09-16
Wednesday, September 16, 2020

Lua

<lang lua>print( os.date( "%Y-%m-%d" ) ) print( os.date( "%A, %B %d, %Y" ) )</lang>

M2000 Interpreter

<lang M2000 Interpreter> Print str$(today, "yyyy-mm-dd") Print str$(today, "dddd, mmm, dd, yyyy") </lang>

Maple

<lang Maple> with(StringTools); FormatTime("%Y-%m-%d") FormatTime("%A,%B %d, %y") </lang>

Mathematica/Wolfram Language

<lang Mathematica>DateString[{"Year", "-", "Month", "-", "Day"}] DateString[{"DayName", ", ", "MonthName", " ", "Day", ", ", "Year"}]</lang>

MATLAB / Octave

<lang MATLAB>>> datestr(now,'yyyy-mm-dd')

ans =

2010-06-18

>> datestr(now,'dddd, mmmm dd, yyyy')

ans =

Friday, June 18, 2010</lang>

min

Works with: min version 0.19.3

<lang min>("YYYY-MM-dd" "dddd, MMMM dd, YYYY") ('timestamp dip tformat puts!) foreach</lang>

Output:
2019-04-02
Tuesday, April 02, 2019

mIRC Scripting Language

<lang mirc>echo -ag $time(yyyy-mm-dd) echo -ag $time(dddd $+ $chr(44) mmmm dd $+ $chr(44) yyyy)</lang>

MUMPS

Works with: Intersystems' Caché version (all versions)

Functions starting with 'Z' or '$Z' are implementation specific. <lang MUMPS>DTZ

WRITE !,"Date format 3: ",$ZDATE($H,3)
WRITE !,"Or ",$ZDATE($H,12),", ",$ZDATE($H,9)
QUIT</lang>

MUMPS contains the integer number of days since December 31, 1840 in the first part of the system variable $HOROLOG.

Works with: MUMPS version all

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

<lang Nanoquery>import Nanoquery.Util

d = new(Date) println d.getYear() + "-" + d.getMonth() + "-" + d.getDay() println d.getDayOfWeek() + ", " + d.getMonthName() + " " + d.getDay() + ", " + d.getYear()</lang>

Neko

<lang ActionScript>/**

<doc>

Date format

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

</doc>
  • /

var date_now = $loader.loadprim("std@date_now", 0) var date_format = $loader.loadprim("std@date_format", 2)

var now = date_now() $print(date_format(now, "%F"), "\n") $print(date_format(now, "%A, %B %d, %Y"), "\n")</lang>

Output:
prompt$ nekoc date-format.neko
prompt$ neko date-format.n
2018-11-13
Tuesday, November 13, 2018

NetRexx

<lang NetRexx> import java.text.SimpleDateFormat say SimpleDateFormat("yyyy-MM-dd").format(Date()) say SimpleDateFormat("EEEE, MMMM dd, yyyy").format(Date()) </lang>

Output:
2019-02-10
Sonntag, Februar 10, 2019

NewLISP

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

Output:
short: 2012-02-01
short: 2012-02-01
long:  Wednesday, February 1, 2012
long:  水曜日, 2月 1, 2012

Nim

<lang Nim>import times

var t = now() echo(t.format("yyyy-MM-dd")) echo(t.format("dddd',' MMMM d',' yyyy"))</lang>

Objeck

<lang 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());
   }
 }

} </lang>

Output:
2012-5-22
Sunday, May 22, 2012

Objective-C

<lang objc>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]);</lang>

Works with: Mac OS X version 10.4+
Works with: iOS

<lang objc>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]]);</lang>

OCaml

<lang ocaml># #load "unix.cma";;

  1. open Unix;;
  1. let t = time() ;;

val t : float = 1219997516.

  1. 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}
  1. Printf.sprintf "%d-%02d-%02d" (1900 + gmt.tm_year) (1 + gmt.tm_mon) gmt.tm_mday ;;

- : string = "2008-08-29"</lang>

<lang ocaml>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" |]
  1. 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"</lang>

ooRexx

<lang 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')</lang>

Output:
2007-11-23

Friday, November 23, 2007 Friday, November 23, 2007 2020-06-05 Friday, June 05, 2020

OxygenBasic

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

Oz

Getting the current local date is easy, but we have to do the formatting manually. <lang oz>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}}}</lang>

Pascal

Works with: Turbo Pascal version 5.5

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

Output:
2010-07-30
Friday, July 30, 2010

Perl

Library: POSIX

<lang 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";</lang>

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: <lang perl>use POSIX;

print strftime('%Y-%m-%d', localtime), "\n"; print strftime('%A, %B %d, %Y', localtime), "\n";</lang>

Output:
with locales C
2008-02-13
Wednesday, February 13, 2008

Phix

Library: Phix/basics
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 <lang php><?php echo date('Y-m-d', time())."\n"; echo date('l, F j, Y', time())."\n"; ?></lang>

PicoLisp

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

Pike

<lang 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" ); </lang>

Output:
2020-01-03
Friday, January 3, 2020

PL/I

Version 1

<lang pli>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;</lang>
Output:
2013-11-02
Saturday, Nov 02, 2013

Version 2

<lang PL/I> 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;</lang>
Output:
2013-11-02
Saturday, November 02, 2013

PowerShell

<lang powershell>"{0:yyyy-MM-dd}" -f (Get-Date) "{0:dddd, MMMM d, yyyy}" -f (Get-Date)

  1. or

(Get-Date).ToString("yyyy-MM-dd") (Get-Date).ToString("dddd, MMMM d, yyyy")</lang> Note: The names of months and days follow the currently set locale but otherwise the format is unchanged.

Prolog

Works with: SWI-Prolog version 6

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

</lang>

PureBasic

Works with: PureBasic version 4.41

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

Python

Formatting rules: http://docs.python.org/lib/module-time.html (strftime)

<lang python>import datetime today = datetime.date.today()

  1. The first requested format is a method of datetime objects:

today.isoformat()

  1. For full flexibility, use the strftime formatting codes from the link above:

today.strftime("%A, %B %d, %Y")

  1. This mechanism is integrated into the general string formatting system.
  2. You can do this with positional arguments referenced by number

"The date is {0:%A, %B %d, %Y}".format(d)

  1. Or keyword arguments referenced by name

"The date is {date:%A, %B %d, %Y}".format(date=d)

  1. Since Python 3.6, f-strings allow the value to be inserted inline

f"The date is {d:%A, %B %d, %Y}" </lang>

R

strftime is short for "string format time". <lang rsplus>now <- Sys.time() strftime(now, "%Y-%m-%d") strftime(now, "%A, %B %d, %Y")</lang>

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>#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"))</lang> 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)

<lang perl6>use DateTime::Format;

my $dt = DateTime.now;

say strftime('%Y-%m-%d', $dt); say strftime('%A, %B %d, %Y', $dt);</lang>

The built-in Date and DateTime classes both offer support for the ISO format: <lang perl6>my $d = Date.today;

say $d.yyyy-mm-dd;</lang>

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

Raven

<lang raven>time int as today</lang>

Short form:

<lang raven>today '%Y-%m-%d' date</lang>

Long form:

<lang raven>today '%A, %B %d, %Y' date</lang>

REBOL

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

Output:
6-Dec-2009/10:02:10-5:00
2009-12-06
Sunday, December 6, 2009

RED

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

Output:
2020-03-25

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

<lang REXX>/*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.*/</lang>
Output:
2010-09-01
Wednesday, September 1, 2010 

compact version

<lang rexx>/*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.*/</lang>

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. <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('W')"," date('M') word(date(), 1)"," left(date('S'),4)

                                      /* [↑]  dayofweek  Month dd, yyyy*/
                                      /*stick a fork in it, we're done.*/

</lang> output would be the same as the 1st version.

Ring

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

  • /

</lang>

Output:
19/07/2020
2020-07-19
Sunday, July 19, 2020

Ruby

Formatting rules: Time#strftime

<lang ruby>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')</lang>

Output:
2015-02-08 10:48:45 +0900
2015-02-08
2015-02-08
Sunday, February 08, 2015

Run BASIC

<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$("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</lang>

Output:
2012-03-16
Friday, March 16, 2012

Rust

Using chrono 0.4.6 <lang rust>fn main() {

   let now = chrono::Utc::now();
   println!("{}", now.format("%Y-%m-%d"));
   println!("{}", now.format("%A, %B %d, %Y"));

}</lang>

Scala

<lang scala>val now=new Date() println("%tF".format(now)) println("%1$tA, %1$tB %1$td, %1$tY".format(now))</lang>

Scheme

Works with: Guile version 2.0.13

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

</lang>

Seed7

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

SenseTalk

<lang sensetalk> put formattedTime( "[year]-[month]-[day]", the date)

put formattedTime( "[weekday], [month name] [day], [year]", the date) </lang>

Output:
2019-12-18
Wednesday, December 18, 2019

Shiny

<lang shiny>say time.format 'Y-m-d' time.now say time.format 'l, F j, Y' time.now</lang>

Sidef

<lang ruby>var time = Time.local; say time.ctime; say time.strftime("%Y-%m-%d"); say time.strftime("%A, %B %d, %Y");</lang>

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.

<lang smalltalk>| d | d := Date today. d printFormat: #(3 2 1 $- 1 1 2). (d weekday asString), ', ', (d monthName), ' ', (d dayOfMonth asString), ', ', (d year asString)</lang>

Works with: Smalltalk/X

<lang smalltalk>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.</lang>

Output:
2020-12-17
Thursday, December 17, 2020
Donnerstag, Dezember 17, 2020
Vendredi, Décembre 17, 2020

SQL

Works with: Oracle

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

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

<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");</lang>

Output:
2008-02-13
Wednesday, February 13, 2008

Stata

Stata has many ways to format dates, see Datetime display formats in the documentation.

<lang stata>display %tdCCYY-NN-DD td($S_DATE) display %tdDayname,_Month_dd,_CCYY td($S_DATE)</lang>

Suneido

<lang Suneido>Date().Format('yyyy-MM-dd') --> "2010-03-16" Date().LongDate() --> "Tuesday, March 16, 2010" </lang>

Swift

<lang 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")</lang>

Output:
2015ꈎ8ꆪ28ꑍ(In Sichuan Yi Language Environment)

Tcl

<lang tcl>set now [clock seconds] puts [clock format $now -format "%Y-%m-%d"] puts [clock format $now -format "%A, %B %d, %Y"]</lang>

Terraform

<lang terraform>locals {

 today = timestamp()

}

output "iso" {

 value = formatdate("YYYY-MM-DD", local.today)

}

output "us-long" {

 value = formatdate("EEEE, MMMM D, YYYY", local.today)

}</lang>

Output:
Apply complete! Resources: 0 added, 0 changed, 0 destroyed.

Outputs:

iso = 2020-09-16
us-long = Wednesday, September 16, 2020

TUSCRIPT

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

Output:
2011-1-5
Wendsday, January 5, 2011

UNIX Shell

<lang bash>date +"%Y-%m-%d" date +"%A, %B %d, %Y"</lang>

On a new enough system %F is equivalent to %Y-%m-%d <lang bash>date +"%F"</lang>


Ursa

Works with: Cygnus/X Ursa

Cygnus/X Ursa can import and call Java classes. <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] > 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 > _</lang>

Ursala

The method is to transform a date in standard format returned by the library function, now. <lang Ursala>#import std

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

  1. show+

main = <.text_form,numeric_form> now0</lang>

Output:
Wednesday, June 24, 2009
2009-06-24

VB-DOS

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

VBA

<lang VBA>Function DateFormats()

   Debug.Print Format(Date, "yyyy-mm-dd")
   Debug.Print Format(Date, "dddd, mmmm dd yyyy")

End Function</lang>

VBScript

<lang vb> '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) </lang>

Output:
2015-08-31
Monday, August 31, 2015

Vedit macro language

Display current date in format "2007-11-10":

<lang vedit>Date(REVERSE+NOMSG+VALUE, '-')</lang>

Display current date in format "Sunday, November 10, 2007" (Requires VEDIT 6.2): <lang vedit>// Get todays date into #1, #2, #3 and #7

  1. 1 = Date_Day
  2. 2 = Date_Month
  3. 3 = Date_Year
  4. 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)</lang>

To insert the date string into edit buffer instead of displaying it, replace the last line with this:

<lang vedit>RI(1) IT(", ") RI(2) IT(" ") NI(#1, LEFT+NOCR) IT(",") NI(#3)</lang>

Vlang

<lang vlang>import time

fn main() {

   println(time.now().custom_format("YYYY-MM-DD"))
   println(time.now().custom_format("dddd, MMMM D, YYYY"))

}</lang>

Output:
2011-12-02
Friday, December 2, 2011

Wren

Library: 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. <lang ecmascript>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"))</lang>

Output:
$ wren date_format.wren 2020-06-05
2020-06-05
Friday, June 5, 2020

XPL0

<lang 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); ]</lang>

Output:
2012-11-20
Tuesday, November 20, 2012

Yabasic

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

zkl

<lang zkl>"%d-%02d-%02d".fmt(Time.Clock.localTime.xplode()).println() //--> "2014-02-28" (ISO format)</lang> 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. <lang zkl>Time.Date.prettyDay(Time.Clock.localTime.xplode()) //--> "Friday, the 28th of February 2014"</lang> <lang zkl>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"</lang>

zonnon

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

Output:
2017-12-05
Tuesday, diciembre 05, 2017