Date format: Difference between revisions

 

=={{header|11l}}==

 

=={{header|68000 Assembly}}==

 

 

MOVE.B #'2',D0 ;a character in single or double quotes refers to its ascii equivalent.

MOVE.B D1,D0 ;store in low word

popWord D1

 

Output can be seen [https://ibb.co/52Ks0yf here,] but is also reproduced below:

 

=={{header|8th}}==

d:new

"%Y-%M-%D" over d:format . cr

"%W, %N %D, %Y" over d:format . cr

bye

 

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program dateFormat64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

=={{header|ABAP}}==

report zdate.

data: lv_month type string,

concatenate sy-datum(4) '-' sy-datum+4(2) '-' sy-datum+6(2) into lv_date.

write / lv_date.

 

=={{header|Action!}}==

 

TYPE Date=[

PrintDateShort(d) PutE()

PrintDateLong(d) PutE()

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Date_format.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

with Ada.Calendar.Formatting; use Ada.Calendar.Formatting;

with Ada.Text_IO; use Ada.Text_IO;

& Year_Number'Image (Ada.Calendar.Year (Today))

);

 

{{out}}

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

 

STRUCT ( INT sec, min, hour, mday, mon, year, wday, yday, isdst) tm = (6,5,4,3,2,1,7,~,8);

 

 

printf((unix time repr, now[wday OF tm], now[mon OF tm], now[mday OF tm],

{{out}}

<pre>

 

=={{header|Apex}}==

Datetime dtNow = datetime.now();

String strDt1 = dtNow.format('yyyy-MM-dd');

system.debug(strDt1); // "2007-11-10"

system.debug(strDt2); //"Sunday, November 10, 2007"

 

{{out}}

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.

 

 

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)

 

 

{{output}}

 

 

===Hack alternative===

 

 

set shortdate to text 1 thru 10 of (it as «class isot» as string)

set longdate to the contents of [its weekday, ", ", ¬

 

log the shortdate

 

{{output}}

Or, emphasising productivity and functional composition:

 

on iso8601Short(dte)

text 1 thru 10 of iso8601Local(dte)

set my text item delimiters to dlm

s

{{Out}}

<pre>2020-09-11

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program dateFormat.s */

/***************************************************/

.include "../affichage.inc"

{{Output}}

<pre>

=={{header|Arturo}}==

 

 

print to :string.format: "YYYY-MM-dd" currentTime

 

{{out}}

 

=={{header|AutoHotkey}}==

FormatTime, Date2, , LongDate ; "Sunday, November 10, 2007"

 

=={{header|AutoIt}}==

This solution uses the locale settings for names of days and months.

#include <Date.au3>

 

Return $ret[3]

EndFunc

{{out}}

<pre>

=={{header|AWK}}==

{{works with|Gawk}}

2009-05-15

 

=={{header|BaCon}}==

n = NOW

PRINT YEAR(n), MONTH(n), DAY(n) FORMAT "%ld-%02ld-%02ld\n"

 

{{out}}

=={{header|BASIC}}==

{{works with|FreeBASIC}}

 

DIM today As Double = Now()

 

PRINT Format(today, "yyyy-mm-dd")

 

=={{header|Batch File}}==

@echo off

setlocal enabledelayedexpansion

echo %fulldayname%, %monthname% %day%, %year%

pause>nul

{{out}}

<pre>

 

=={{header|BBC BASIC}}==

months$ = "January February March April May June " + \

\ "July August September October November December"

DEF FNrtrim(A$)

WHILE RIGHT$(A$) = " " A$ = LEFT$(A$) : ENDWHILE

 

=={{header|Beads}}==

// [iso time] = [hour]:[minute]:[second], e.g. 18:06:05

</pre>

 

calc main_init

log time_to_str('[iso date]')

 

{{out}}

=={{header|C}}==

#include <stdio.h>

#include <time.h>

(void) printf("%s\n", buf);

return EXIT_SUCCESS;

{{out}}

<pre>

 

=={{header|C sharp|C#}}==

 

namespace RosettaCode.DateFormat

}

}

 

=={{header|C++}}==

// and "Sunday, November 10, 2007".

 

std::cout << d.getTextDate() << std::endl;

return 0;

{{out}}

<pre>

 

=={{header|Clojure}}==

f1 (java.text.SimpleDateFormat. "yyyy-MM-dd")

f2 (java.text.SimpleDateFormat. "EEEE, MMMM dd, yyyy")]

(println (.format f1 now))

 

{{out}}

=={{header|COBOL}}==

{{works with|OpenCOBOL}}

PROGRAM-ID. Date-Format.

 

 

GOBACK

 

=={{header|CoffeeScript}}==

=== ECMAScript ≥ 5.1 ===

Is supported by at least: Chrome 24, Firefox/Gecko 29, IE 11, Opera 15, and Node.js (at least as of 2015).

date = new Date

 

day: 'numeric'

year: 'numeric'

 

=== Portable version ===

# JS does not have extensive formatting support out of the box. This code shows

# how you could create a date formatter object.

console.log formatter.brief(date)

console.log formatter.verbose(date)

{{out}}

<pre>

 

=={{header|ColdFusion}}==

#dateFormat(Now(), "YYYY-MM-DD")#<br />

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

 

=={{header|Common Lisp}}==

#("Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday" "Sunday"))

(defconstant *month-names*

(format t "~4d-~2,'0d-~2,'0d~%" year month date)

(format t "~a, ~a ~d, ~4d~%"

 

With the local-time library:

 

(local-time:format-timestring nil (local-time:now) :format '(:year "-" (:month 2) "-" (:day 2)))

;; => "2019-11-13"

(local-time:format-timestring nil (local-time:now) :format '(:long-weekday ", " :long-month #\space (:day 2) ", " :year))

;; => "Wednesday, November 13, 2019"

 

=={{header|Component Pascal}}==

BlackBox Component Builder

MODULE DateFormat;

IMPORT StdLog, Dates;

END Do;

END DateFormat.

Execute: ^Q DateFormat.Do<br/>

{{out}}

=={{header|Crystal}}==

{{works with|Crystal|0.33}}

 

time = Time.local

puts time.to_s("%Y-%m-%d")

puts time.to_s("%A, %B %d, %Y")

 

=={{header|D}}==

{{works with|D|DMD 1.026}}

{{libheader|Tango}}

 

import tango.time.Time ;

d = g.toTime(2008, 2, 1, 0, 0, 0, 0, g.AD_ERA) ;

Stdout.format("{:dddd, MMMM d, yyy}", d).newline ;

{{out}}

<pre>2007-11-10

 

=={{header|Delphi}}==

{{out}}

<pre>

Redirecting to

</pre>

 

=={{header|EGL}}==

// 2012-09-26

SysLib.writeStdout(StrLib.formatDate(DateTimeLib.currentDate(), "yyyy-MM-dd"));

SysLib.setLocale("en", "US");

SysLib.writeStdout(StrLib.formatDate(DateTimeLib.currentDate(), "EEEE, MMMM dd, yyyy"));

{{out}}

<pre>

{{trans|Erlang}}

{{works with|Elixir|1.4}}

def iso_date, do: Date.utc_today |> Date.to_iso8601

IO.puts Date_format.long_date

IO.puts Date_format.iso_date(2007,11,10)

 

{{out}}

 

=={{header|Emacs Lisp}}==

(format-time-string "%F") ;; new in Emacs 24

;; => "2015-11-08"

 

(format-time-string "%A, %B %e, %Y")

 

<code>%e</code> is blank-padded day number, or <code>%d</code> for zero-padded. Month and weekday names follow the current locale. On a POSIX style system this is the usual <code>LC_TIME</code> or <code>LC_ALL</code> environment variables. GNU Emacs variable <code>system-time-locale</code> can override this if desired.

=={{header|Erlang}}==

 

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

MonthName = element(Month, Months),

append([WeekdayName, ", ", MonthName, " ", integer_to_list(Day), ", ",

 

=={{header|Euphoria}}==

constant months = {"January","February","March","April","May","June",

"July","August","September","October","November","December"}

 

printf(1,"%d-%02d-%02d\n",now[1..3])

 

=={{header|F_Sharp|F#}}==

"F# Interactive" session:

> Console.WriteLine( DateTime.Now.ToString("yyyy-MM-dd") );;

2010-08-13

> Console.WriteLine( "{0:D}", DateTime.Now );;

 

=={{header|Factor}}==

 

now "%Y-%m-%d" strftime print

 

=={{header|Fantom}}==

Today's date can be retrieved using 'Date.today'. The 'toLocale' method can be passed formatting information to determine how the date should be represented as a string. The rules are described at http://fantom.org/doc/sys/Date.html#toLocale

 

fansh> Date.today.toLocale("YYYY-MM-DD")

2011-02-24

fansh> Date.today.toLocale("WWWW, MMMM DD, YYYY")

Thursday, February 24, 2011

 

=={{header|Forth}}==

[char] - emit

dup 10 < if [char] 0 emit then ;

3dup weekday weekdays type ." , "

>R 1- months type space 1 u.r ." , " R> .

 

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

 

 

\ utility words

\ Rosetta Date Format 2

: LONG.DATE ( d m y -- )

 

 

Test at the Forth Console

ok

5 7 2018 LONG.DATE Thursday, July 05, 2018 ok

 

=={{header|Fortran}}==

{{works with|Fortran|95 and later}}

The subroutine DATE_AND_TIME does not return day of week information so we have to write our own function for that

 

IMPLICIT NONE

END FUNCTION Day_of_week

 

{{out}}

2008-12-14

 

=={{header|FreeBASIC}}==

 

#Include "vbcompat.bi"

Print

Print "Press any key to quit the program"

 

{{out}}

 

=={{header|Free Pascal}}==

uses

SysUtils;

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

end.

{{out}}

<pre>

 

=={{header|Frink}}==

println[now[] -> ### yyyy-MM-dd ###]

println[now[] -> ### EEEE, MMMM d, yyyy ###]

 

=={{header|FunL}}==

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/ You can run this code. Copy the code, click this link, paste it in and press 'Run !']'''

 

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

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

 

Output:

<pre>

=={{header|Go}}==

In an interesting design, you specify your format by providing the format for the date and time 01/02 03:04:05PM '06 -0700

 

import "time"

fmt.Println(time.Now().Format("2006-01-02"))

fmt.Println(time.Now().Format("Monday, January 2, 2006"))

{{out}}

<pre>

=={{header|Groovy}}==

Solution:

 

Test Program:

println isoFormat(now)

 

=={{header|Haskell}}==

(FormatTime, formatTime, defaultTimeLocale, utcToLocalTime,

getCurrentTimeZone, getCurrentTime)

main = do

t <- pure utcToLocalTime <*> getCurrentTimeZone <*> getCurrentTime

'''Sample output:'''

<pre>2017-06-05

 

=={{header|HicEst}}==

 

WRITE(Text=string, Format='UCCYY-MM-DD') 0 ! string: 2010-03-13

EDIT(Text=string, Right=' ', Mark1, Right=';', Right=3, Mark2, Delete, Insert=', '//cMonth, Right=';', RePLaceby=',')

 

 

=={{header|Icon}} and {{header|Unicon}}==

write(map(&date,"/","-"))

write(&dateline ? tab(find(&date[1:5])+4))

 

{{out}}

=={{header|J}}==

Short format using built in formatting:

 

Verb to show custom format:

days=:;:'Sunday Monday Tuesday Wednesday Thursday Friday Saturday'

fmtDate=: [:((days ;@{~ weekday),', ',ms0) 3 {.]

 

fmtDate 6!:0 ''

 

=={{header|Java}}==

import java.util.Calendar;

import java.util.GregorianCalendar;

}

}

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

 

===Java 8 Date Time API===

import java.time.LocalDate;

import java.time.format.DateTimeFormatter;

}

}

 

===Java Util Date API===

import java.text.SimpleDateFormat;

import java.util.Date;

}

}

 

=={{header|JavaScript}}==

JavaScript does not have any built-in <code>strftime</code>-type functionality.

weekdays = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],

months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],

fmt2 = weekdays[now.getDay()] + ', ' + months[now.getMonth()] + ' ' + now.getDate() + ', ' + now.getFullYear();

console.log(fmt1);

<pre>2010-1-12

Tuesday, January 12, 2010</pre>

 

=={{header|Joy}}==

 

[i] map [putchars] step '\n putch pop.

 

 

=={{header|jq}}==

{{works with|jq|with strftime}}

"2015-07-02"

 

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

{{works with|Julia|0.6}}

 

 

println("Today's date is:")

println("\t$ts")

 

{{out}}

 

=={{header|Kotlin}}==

 

import java.util.GregorianCalendar

println("%tF".format(now))

println("%tA, %1\$tB %1\$te, %1\$tY".format(now))

 

{{out}}

 

=={{header|langur}}==

var .format1 = "2006-01-02"

var .format2 = "Monday, January 2, 2006"

 

writeln $"\.now:dt(2006-01-02);"

 

 

{{out}}

 

=={{header|Lasso}}==

date('11/10/2007')->format('%Q') // 2007-11-10

date('11/10/2007')->format('EEEE, MMMM d, YYYY') //Saturday, November 10, 2007

 

 

=={{header|Liberty BASIC}}==

d$=date$("yyyy/mm/dd")

print word$(d$,1,"/")+"-"+word$(d$,2,"/")+"-"+word$(d$,3,"/")

monthLong$="January February March April May June July August September October November December"

 

 

 

=={{header|LiveCode}}==

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

 

=={{header|Logo}}==

{{works with|UCB Logo}}

A bit of a cheat since Logo has no standard built-in time and date functions, but UCB Logo can call out to the shell, so:

print first shell [date +%F]

print first shell [date +"%A, %B %d, %Y"]

{{Out}}

<pre>2020-09-16

 

=={{header|Lua}}==

 

=={{header|M2000 Interpreter}}==

Print str$(today, "yyyy-mm-dd")

Print str$(today, "dddd, mmm, dd, yyyy")

 

=={{header|Maple}}==

 

with(StringTools);

FormatTime("%Y-%m-%d")

FormatTime("%A,%B %d, %y")

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

 

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

 

ans =

ans =

 

 

=={{header|min}}==

{{works with|min|0.19.3}}

{{out}}

<pre>

2019-04-02

Tuesday, April 02, 2019

</pre>

 

=={{header|mIRC Scripting Language}}==

 

=={{header|MUMPS}}==

{{works with|MUMPS|Intersystems' Caché|(all versions)}}

Functions starting with 'Z' or '$Z' are implementation specific.

WRITE !,"Date format 3: ",$ZDATE($H,3)

WRITE !,"Or ",$ZDATE($H,12),", ",$ZDATE($H,9)

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

{{works with|MUMPS|all}}

;You can pass an integer, but the default is to use today's value

SET:$DATA(H)=0 H=$HOROLOG

WRITE !,$P(DN,",",DOW),", ",$P(MN,",",MO)," ",DA,", ",YR

KILL Y,YR,RD,MC,MO,DA,MN,DN,DOW

Demos:<pre>

USER>D DTM^ROSETTA

 

=={{header|Nanoquery}}==

 

d = new(Date)

println d.getYear() + "-" + d.getMonth() + "-" + d.getDay()

 

=={{header|Neko}}==

<doc>

<h2>Date format</h2>

var now = date_now()

$print(date_format(now, "%F"), "\n")

{{out}}

<pre>prompt$ nekoc date-format.neko

 

=={{header|NetRexx}}==

import java.text.SimpleDateFormat

say SimpleDateFormat("yyyy-MM-dd").format(Date())

say SimpleDateFormat("EEEE, MMMM dd, yyyy").format(Date())

{{out}}

<pre>2019-02-10

 

=={{header|NewLISP}}==

; url: http://rosettacode.org/wiki/Date_format

; author: oofoe 2012-02-01

(println "long: " (date (date-value) 0 "%A, %B %#d, %Y"))

 

 

{{out}}

 

=={{header|Nim}}==

 

var t = now()

echo(t.format("yyyy-MM-dd"))

 

=={{header|Objeck}}==

use IO;

use Time;

}

}

 

{{out}}

 

=={{header|Objective-C}}==

NSLog(@"%@", [[NSDate date] descriptionWithCalendarFormat:@"%Y-%m-%d" timeZone:nil locale:nil]);

 

{{works with|Mac OS X|10.4+}}

{{works with|iOS}}

NSDateFormatter *dateFormatter = [[NSDateFormat alloc] init];

[dateFormatter setDateFormat:@"yyyy-MM-dd"];

NSLog(@"%@", [dateFormatter stringFromDate:[NSDate date]]);

[dateFormatter setDateFormat:@"EEEE, MMMM d, yyyy"];

 

=={{header|OCaml}}==

 

# open Unix;;

 

 

# Printf.sprintf "%d-%02d-%02d" (1900 + gmt.tm_year) (1 + gmt.tm_mon) gmt.tm_mday ;;

 

"July"; "August"; "September"; "October"; "November"; "December" |]

 

gmt.tm_mday

(1900 + gmt.tm_year) ;;

 

=={{header|ooRexx}}==

dats='20071123'

Say date('I',dats,'S')

dati=date('I')

Say dati

{{out}}2007-11-23

Friday, November 23, 2007

 

=={{header|OxygenBasic}}==

extern lib "kernel32.dll"

 

print "" t.wYear "-" month "-" day

print WeekDay[t.wDayOfWeek+1 and 7 ] " " MonthName[t.wMonth and 31] " " t.wDay " " t.wYear

 

=={{header|Oz}}==

Getting the current local date is easy, but we have to do the formatting manually.

WeekDays = unit(0:"Sunday" "Monday" "Tuesday" "Wednesday"

"Thursday" "Friday" "Saturday")

in

{System.showInfo {DateISO {OS.localTime}}}

 

=={{header|Pascal}}==

{{works with|Turbo Pascal|5.5}}

uses DOS;

 

mname := m2s(mo); dname := d2s(dow);

writeln(dname,', ',mname,' ',dy,', ',yr)

 

{{out}}

=={{header|Perl}}==

{{libheader|POSIX}}

 

print strftime('%Y-%m-%d', 0, 0, 0, 10, 10, 107), "\n";

 

{{out}} with locales '''C''':

 

Actual date:

 

print strftime('%Y-%m-%d', localtime), "\n";

 

{{out}} with locales '''C''':

=={{header|Phix}}==

{{libheader|Phix/basics}}

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">\</span><span style="color: #004080;">timedate</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">format_timedate</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">date</span><span style="color: #0000FF;">(),</span><span style="color: #008000;">"YYYY-MM-DD"</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">format_timedate</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">date</span><span style="color: #0000FF;">(),</span><span style="color: #008000;">"Dddd, Mmmm d, YYYY"</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

=={{header|PHP}}==

Formatting rules: http://www.php.net/date

echo date('Y-m-d', time())."\n";

echo date('l, F j, Y', time())."\n";

 

=={{header|PicoLisp}}==

(prinl (dat$ Date "-")) # 2010-02-19

(prinl # Friday, February 19, 2010

(caddr Lst)

", "

 

=={{header|Pike}}==

object cal = Calendar.ISO.Day();

write( cal->format_ymd() +"\n" );

cal->year_no());

write( special +"\n" );

{{Out}}

<pre>

=={{header|PL/I}}==

===Version 1===

declare day_of_week(7) character (9) varying initial(

'Sunday','Monday','Tuesday','Wednesday',

put edit(substr(today,1,3),' ',substr(today,4,2),', ',

substr(today,6,4))(A);

{{out}}

<pre>2013-11-02

 

===Version 2===

declare day_of_week(7) character(9) varying initial(

'Sunday','Monday','Tuesday','Wednesday',

put edit(month(substr(today,1,2)),' ',substr(today,3,2),', ',

substr(today,5,4))(A);

{{out}}

<pre>2013-11-02

 

=={{header|PowerShell}}==

"{0:dddd, MMMM d, yyyy}" -f (Get-Date)

# or

(Get-Date).ToString("yyyy-MM-dd")

''Note:'' The names of months and days follow the currently set locale but otherwise the format is unchanged.

 

{{works with|SWI-Prolog|6}}

 

display_date :-

get_time(Time),

format_time(atom(Long), '%A, %B %d, %Y', Time),

format('~w~n~w~n', [Short, Long]).

 

=={{header|PureBasic}}==

{{works with|PureBasic|4.41}}

Declare.s MonthInText()

Declare.s DayInText()

EndSelect

ProcedureReturn m$

 

=={{header|Python}}==

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

 

today = datetime.date.today()

# The first requested format is a method of datetime objects:

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

f"The date is {d:%A, %B %d, %Y}"

 

=={{header|R}}==

strftime is short for "string format time".

strftime(now, "%Y-%m-%d")

 

=={{header|Racket}}==

See: http://srfi.schemers.org/srfi-19/srfi-19.html

 

(require srfi/19)

 

(displayln (date->string (current-date) "~A, ~B ~d, ~Y"))

;;; ~e is space padded day of month:

both ~d and ~e satisfy the format required, since the "10" part of that date is 2-digit

 

(formerly Perl 6)

{{libheader|DateTime&#58;&#58;Format}}

 

my $dt = DateTime.now;

 

say strftime('%Y-%m-%d', $dt);

 

The built-in Date and DateTime classes both offer support for the ISO format:

 

 

They don't include the longer format specified in the task, but you can always roll your own formatter instead of importing the library:

 

August September October November December>;

my @days = <Monday Tuesday Wednesday Thursday Friday Saturday Sunday>;

 

say $d.yyyy-mm-dd; # still works

 

=={{header|Raven}}==

 

Short form:

 

 

Long form:

 

 

=={{header|REBOL}}==

Title: "Date Formatting"

URL: http://rosettacode.org/wiki/Date_format

pick system/locale/months now/month " "

now/day ", " now/year

 

{{out}}

Sunday, December 6, 2009</pre>

=={{header|RED}}==

Red []

;; zeropad

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]

{{out}}<pre>2020-03-25

Wednesday, March 25, 2020

<br>It's up to the programmer to choose whatever version of the &nbsp; '''date''' &nbsp; BIF that best serves the purpose.

===idiomatic version===

x = date('S') /*get current date as yyyymmdd */

yyyy = left(x,4) /*pick off year (4 digs).*/

zdd = dd+0 /*remove leading zero from DD */

say weekday',' month zdd"," yyyy /*format date as: Month dd, yyyy*/

{{out}}

<pre>

 

===compact version===

/* ╔══════════════════════════════════════════════════════════════════╗

║ function returns a specific example ║

say date('W')"," date('M') word(date(), 1)"," yyyy

/* [↑] dayofweek Month dd, yyyy*/

'''output''' would be the same as the 1^st version.

 

===modern version===

This version can be used with those REXXes that support the &nbsp; '''I''' &nbsp; (ISO) parameter for the &nbsp; '''date''' &nbsp; BIF.

say date('I') /*yyyy-mm-dd with leading zeroes.*/

 

/* [↑] dayofweek Month dd, yyyy*/

/*stick a fork in it, we're done.*/

'''output''' would be the same as the 1^st version.

<br><br>

 

=={{header|Ring}}==

dateStr = date()

date1 = timelist()[19] + "-" + timelist()[10] + "-" + timelist()[6]

*/

 

{{out}}

<pre>

2020-07-19

Sunday, July 19, 2020

</pre>

 

Formatting rules: [//www.ruby-doc.org/core/Time.html#method-i-strftime Time#strftime]

 

puts Time.now.strftime('%Y-%m-%d')

puts Time.now.strftime('%F') # same as %Y-%m-%d (ISO 8601 date formats)

{{out}}

<pre>

 

=={{header|Run BASIC}}==

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)

{{out}}

<pre>

=={{header|Rust}}==

Using <code>chrono 0.4.6</code>

let now = chrono::Utc::now();

println!("{}", now.format("%Y-%m-%d"));

println!("{}", now.format("%A, %B %d, %Y"));

 

=={{header|Scala}}==

println("%tF".format(now))

 

=={{header|Scheme}}==

{{works with|Guile|2.0.13}}

 

(lambda (lt)

(strftime "%Y-%m-%d" (localtime lt))))

(display (long-date dt))(newline))))

 

 

=={{header|Seed7}}==

include "time.s7i";

writeln(strDate(now));

writeln(days[dayOfWeek(now)] <& ", " <& months[now.month] <& " " <& now.day <& ", " <& now.year);

 

=={{header|SenseTalk}}==

put formattedTime( "[year]-[month]-[day]", the date)

 

put formattedTime( "[weekday], [month name] [day], [year]", the date)

{{out}}

<pre>2019-12-18

 

=={{header|Shiny}}==

 

=={{header|Sidef}}==

say time.ctime;

say time.strftime("%Y-%m-%d");

{{out}}

<pre>

In Smalltalk, one sends a <tt>printFormat</tt> message to a Date object with year, month, and day. For other date strings, one must construct the date string from the parts of a Date object. Of course, you'd probably want to make a method for doing so.

 

d := Date today.

d printFormat: #(3 2 1 $- 1 1 2).

{{works with|Smalltalk/X}}

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.

{{out}}

<pre>2020-12-17

Donnerstag, Dezember 17, 2020

Vendredi, Décembre 17, 2020</pre>

 

=={{header|SQL}}==

{{works with|Oracle}}

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;

 

<pre>

Formatting rules: http://www.standardml.org/Basis/date.html#SIG:DATE.fmt:VAL

 

{{out}}

<pre>

Stata has many ways to format dates, see [https://www.stata.com/help.cgi?Datetime_display_formats Datetime display formats] in the documentation.

 

 

=={{header|Suneido}}==

 

=={{header|Swift}}==

extension String {

func toStandardDateWithDateFormat(format: String) -> String {

}

 

 

{{out}}

 

=={{header|Tcl}}==

puts [clock format $now -format "%Y-%m-%d"]

 

=={{header|Terraform}}==

today = timestamp()

}

output "us-long" {

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

 

{{Out}}

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

SET dayofweek = DATE (today,day,month,year,number)

PRINT format1

PRINT format2

{{out}}

<pre>

 

=={{header|UNIX Shell}}==

 

On a new enough system <code>%F</code> is equivalent to <code>%Y-%m-%d</code>

 

<!-- ENHANCE-ME: what is new enough for %F ? For example it doesn't appear in these bits of POSIX,

{{works with|Cygnus/X Ursa}}

Cygnus/X Ursa can import and call Java classes.

[Oracle Corporation JVM 1.8.0_51 on Mac OS X 10.10.5 x86_64]

> import "java.util.Date"

> out (sdf.format d) endl console

Saturday, July 23, 2016

 

=={{header|Ursala}}==

The method is to transform a date in standard format returned by the library function, now.

#import cli

 

#show+

 

{{out}}

<pre>Wednesday, June 24, 2009

=={{header|VB-DOS|PDS 7.1 BASIC}}==

{{works with|Visual Basic for DOS and PDS 7.1}}

OPTION EXPLICIT

 

 

END

 

=={{header|VBA}}==

 

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

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

 

=={{header|VBScript}}==

'YYYY-MM-DD format

WScript.StdOut.WriteLine Year(Date) & "-" & Right("0" & Month(Date),2) & "-" & Right("0" & Day(Date),2)

'Weekday_Name, Month_Name DD, YYYY format

WScript.StdOut.WriteLine FormatDateTime(Now,1)

 

{{Out}}

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

 

 

Display current date in format "Sunday, November 10, 2007" (Requires VEDIT 6.2):

#1 = Date_Day

#2 = Date_Month

 

// Display the date string

 

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

 

 

 

 

fn main() {

println(time.now().custom_format("YYYY-MM-DD"))

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

{{out}}

<pre>

{{libheader|Wren-date}}

Unless it is embedded in a host application, Wren currently has no direct way to obtain the current date. We therefore assume this is passed in by the user as a command line parameter.

 

var args = Process.arguments

var current = Date.parse(args[0])

System.print(current.format(Date.isoDate))

 

{{out}}

 

=={{header|XPL0}}==

int CpuReg, Year, Month, Day, DName, MName, WDay;

[CpuReg:= GetReg; \access CPU registers

Text(0, DName(WDay)); Text(0, ", "); Text(0, MName(Month)); Text(0, " ");

IntOut(0, Day); Text(0, ", "); IntOut(0, Year); CrLf(0);

 

{{out}}

 

=={{header|Yabasic}}==

 

n = token(date$, n$(), "-")

return month$(int(n/3) + 1)

 

=={{header|zkl}}==

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.

"%s, %s %d, %d".fmt(D.dayName(D.weekDay(y,m,d)),

D.monthName(m), d,y)

 

=={{header|zonnon}}==

module Main;

import System;

System.Console.WriteLine("{0}, {1}",now.DayOfWeek,now.ToString("MMMM dd, yyyy"));

end Main.

{{Out}}

<pre>