Date manipulation: Difference between revisions
m
syntax highlighting fixup automation
(Add Swift) |
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
||
Line 12:
=={{header|11l}}==
<
print((time:strptime(‘March 7 2009 7:30pm’, format_str)
+ TimeDelta(hours' 12)).strftime(format_str))</
=={{header|Ada}}==
Line 21:
Only standard libraries are required.
<
with Ada.Calendar.Formatting;
with Ada.Calendar.Time_Zones;
Line 117:
Put_Line ("T1 => " & Img (T1, EST) & " = " & Img (T1, Lisbon));
Put_Line ("T2 => " & Img (T2, EST) & " = " & Img (T2, Lisbon));
end;</
Result:
Line 127:
=={{header|AppleScript}}==
AppleScript has a built-in date class and can coerce a string to a date automatically. It also has reserved constants such as <code>hours</code> which are defined in the unit of seconds. There is no built-in support for time zones.
<
return (date x) + 12 * hours</
Result is:
<
The above is problematical in that:
Line 140:
However, AppleScript can run shell scripts and, more recently, access some of the system's Objective-C API through its hybrid form AppleScriptObjectiveC. So as long as the date format's known, the task is doable:
<
use framework "Foundation"
Line 161:
end dateManipulationTask
dateManipulationTask()</
{{output}}
Line 168:
=={{header|Arturo}}==
<
formatDate: function [dt][
to :string .format: "MMMM d yyyy h:mmtt" dt
Line 180:
print ["initial:" formatDate initial]
print ["after 12 hours:" formatDate after.hours:12 initial]</
{{out}}
Line 188:
=={{header|AutoHotkey}}==
<
; split the given string with RegExMatch
Line 252:
Result := "12"
Return, Result
}</
{{out|Message box shows}}
<pre>Given: March 7 2009 7:30pm EST
Line 261:
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f DATE_MANIPULATION.AWK
BEGIN {
Line 280:
exit(0)
}
</syntaxhighlight>
{{out}}
<pre>
Line 288:
=={{header|Batch File}}==
<
@echo off
Line 370:
echo Manipulated - %monthname% %day% %year% %hour%:%minutes%%ampm% %timezone%
exit /b
</syntaxhighlight>
The code takes 3 inputs to demonstrate the ability to deal with leap years.
Line 392:
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<
date$ = "March 7 2009 7:30pm EST"
Line 424:
\ ":" + RIGHT$("0"+STR$(mins%), 2) + ampm$ + " " + zone$
ENDPROC
</syntaxhighlight>
{{out}}
<pre>March 8 2009 7:30am EST
Line 432:
=={{header|C}}==
{{works with|POSIX}}
<
#include <stdlib.h>
#include <time.h>
Line 450:
return EXIT_SUCCESS;
}</
Note: <code>ctime</code> treats the date as local, so that it is like the timezone information were discarded (to see the passage to daylight saving time I must change the date into March 28... no matter the timezone specified)
=={{header|C sharp|C#}}==
<
{
static void Main(string[] args)
Line 468:
Console.ReadLine();
}
}</
=={{header|C++}}==
Line 474:
compiled with g++ -lboost_date_time
<
#include <iostream>
#include <boost/date_time/local_time/local_time.hpp>
Line 541:
return 0 ;
}
</syntaxhighlight>
{{out}}
<pre>
Line 551:
=={{header|Clojure}}==
<
java.text.SimpleDateFormat)
Line 561:
long
(Date. ,)
(->> , (.format sdf ,)))))</
=={{header|COBOL}}==
Line 568:
Two parts to this example. Following the task spec using POSIX routines, and a more standardized COBOL form. COBOL 2014 uses ISO8601 date and time formats, and these formats may be more common in COBOL applications.
<
program-id. date-manipulation.
Line 689:
.
end program date-manipulation.
</syntaxhighlight>
{{out}}
Line 704:
=={{header|Crystal}}==
<
time += 12.hours
puts time # 2009-03-08 07:30:00 -05:00
puts time.in(Time::Location.load("Europe/Berlin")) # 2009-03-08 13:30:00 +01:00
</syntaxhighlight>
=={{header|D}}==
<syntaxhighlight lang="d">
import std.stdio;
import std.format;
Line 744:
}
</syntaxhighlight>
{{out}}
<pre>
Line 752:
=={{header|Delphi}}==
<syntaxhighlight lang="delphi">
program DateManipulation;
Line 834:
Readln;
end.
</syntaxhighlight>
{{out}}
Line 840:
=={{header|EchoLisp}}==
<
(define my-date (string->date "March 7 2009 7:30 pm EST"))
→ Sun Mar 08 2009 01:30:00 GMT+0100 (CET)
Line 850:
(date->string my-date)
→ "8/3/2009 13:30:00" ;; human localized, Paris time.
</syntaxhighlight>
----
Line 856:
=={{header|Erlang}}==
It is human readable to me.
<syntaxhighlight lang="erlang">
-module( date_manipulation ).
Line 897:
time_from_strings_hour( Hour, "am" ) -> erlang:list_to_integer( Hour );
time_from_strings_hour( Hour, "pm" ) -> erlang:list_to_integer( Hour ) + 12.
</syntaxhighlight>
{{out}}
<pre>
Line 905:
=={{header|Euphoria}}==
<syntaxhighlight lang="euphoria">
--Date Manipulation task from Rosetta Code wiki
--User:Lnettnay
Line 916:
dt = add(dt, 12, HOURS)
printf(1, "%s EST\n", {format(dt, "%B %d %Y %I:%M %p")})
</syntaxhighlight>
{{out}}
<pre>
Line 925:
The .NET framework does not support parsing of time zone identifiers like "EST". We have to use time zone offsets like "-5".
<
let main() =
Line 938:
Console.WriteLine( "12 hours later in EST : {0}", date2_est )
main()</
{{out}} (depends on locale settings):
Line 947:
=={{header|Factor}}==
<
combinators io kernel math math.parser sequences splitting
unicode ;
Line 968:
"March 7 2009 7:30pm EST" parse-date dup 12 hours time+
[ timestamp>rfc822 print ] bi@</
{{out}}
<pre>
Line 979:
In the expression "d + 12hr", the "12hr" defines an instance of the Duration class, interpreting the duration in nanoseconds.
<
fansh> d := DateTime.fromLocale("March 7 2009 7:30pm EST", "MMMM D YYYY h:mmaa zzz")
fansh> d
Line 987:
fansh> (d+12hr).toTimeZone(TimeZone("London")) // the extra credit!
2009-03-08T12:30:00Z London
</syntaxhighlight>
=={{header|FreeBASIC}}==
<
#include "vbcompat.bi"
Line 1,075:
Print
Print "Press any key to quit"
Sleep</
{{out}}
Line 1,088:
and automatically converts between timezones.
By default, output times are in the user's defined timezone.
<
### MMM dd yyyy h:mma ###
d = parseDate["March 7 2009 7:30pm EST"]
println[d + 12 hours -> Eastern]
println[d + 12 hours -> Switzerland] // Extra credit
</syntaxhighlight>
{{out}}
Line 1,102:
=={{header|FunL}}==
<
pattern = SimpleDateFormat( 'MMMM d yyyy h:mma zzz' )
Line 1,109:
println( pattern.format(later) ) // Eastern Daylight Time
pattern.setTimeZone( TimeZone.getTimeZone('America/Los_Angeles') )
println( pattern.format(later) ) // U.S. Pacific Time</
{{out}}
Line 1,127:
=={{header|Go}}==
<
import (
Line 1,157:
fmt.Println("+12 hrs in Arizona:", t.In(atz))
}
}</
{{out}}
<pre>
Line 1,169:
{{libheader|Joda Time|2.1}}
<
import java.text.*
Line 1,180:
println (dt)
println (dt.plusHours(12))
println (dt.plusHours(12).withZone(DateTimeZone.UTC))</
{{out}}
Line 1,189:
=={{header|Haskell}}==
<
import qualified Data.Time.Format as F
Line 1,202:
"%B %e %Y %l:%M%P %Z"
"March 7 2009 7:30pm EST"
t2 = P.posixSecondsToUTCTime $ 12 * 60 * 60 + P.utcTimeToPOSIXSeconds t1</
{{Out}}
<pre>2009-03-08 12:30:00 UTC</pre>
=={{header|HicEst}}==
<
CHARACTER date="March 7 2009 7:30pm EST", am_pm, result*20
Line 1,218:
! result = "Sun 2009-03-08 07:30"
END
</syntaxhighlight>
=={{header|Icon}} and {{header|Unicon}}==
This uses the datetime procedures from the Icon Programming Library. Several supplemental procedures were needed to normalize the date format (as the one used in the task isn't fully compatible with the library), and to better handle time zones (as the library routines don't handle part hour time zones).
<
procedure main()
Line 1,288:
}
return case x of { "list" : AZ ; "table" : TZ }
end</
{{libheader|Icon Programming Library}}
Line 1,305:
With that in mind:
<
months=: <;._2 tolower 0 :0
January
Line 1,331:
getts=: getyear, getmonth, getday, gethour, getminsec
timeadd=: 1&tsrep@+&tsrep
deltaT=: (1 tsrep 0)&([ + -@#@[ {. ])</
This parser assumes that numeric date information appears to the left of time information, that month name is spelled out in full and that time zone may be ignored. (Alternate date representations are straightforward to implement but turn this into a somewhat open-ended problem).
Line 1,339:
Example use:
<
2009 3 8 7 30 0
timestamp (deltaT 12 0 0) timeadd getts 'March 7 2009 7:30pm EST'
08 Mar 2009 07:30:00
isotimestamp (deltaT 12 0 0) timeadd getts 'March 7 2009 7:30pm EST'
2009-03-08 07:30:00.000</
Note that the isotimestamp representation uses a space instead of a 'T' to separate date and time.
=={{header|Java}}==
<
import java.time.format.*;
Line 1,370:
}
}
</syntaxhighlight>
{{out}}
<pre>
Line 1,392:
While ECMA-262 Ed 5 specifies a <code>Date.parse</code> method, it is not widely supported (2011) and parsing of strings other than the format specified are implementation dependent. Since the test string doesn't conform to the standard, it must be manually parsed.
<
// Get the parts of the date string
Line 1,432:
'Input: ' + inputDateString + '\n' +
'+12hrs in local time: ' + add12hours(inputDateString)
);</
=={{header|jq}}==
{{works with|jq|version with mktime}}
<
| strptime("%B %d %Y %I:%M%p %Z")
| .[3] += 12
| mktime | strftime("%B %d %Y %I:%M%p %Z") </
{{out}}
<
=={{header|Julia}}==
===without TimeZones library===
<
function main()
Line 1,458:
main()
</
<pre>March 08 2009 07:30</pre>
===With TimeZones.jl===
<
function testdateparse()
Line 1,475:
testdateparse()
</
<pre>March 07 2009 07:30AM +05:00</pre>
=={{header|Kotlin}}==
<
import java.text.SimpleDateFormat
Line 1,497:
cal.timeZone = TimeZone.getTimeZone("MST")
println(fmt.format(cal))
}</
{{out}}
Line 1,509:
{{works with|langur|0.10.1}}
<
val .iformat = "January 2 2006 3:04pm -07:00" # input format
val .format = "January 2 2006 3:04pm MST" # output format
Line 1,532:
writeln $"in UTC: \.d5; (\.d5:dt.format;)"
writeln $"+02:30 time zone: \.d6; (\.d6:dt.format;)"
writeln $"in EST: \.d7; (\.d7:dt.format;)"</
{{out}}
Line 1,549:
=={{header|Lasso}}==
<
#date->add(-hour = 24)
#date->timezone = 'GMT'</
{{out}}
Line 1,557:
=={{header|Lingo}}==
<
-- Returns string representation of given date object in YYYY-MM-DD hh:mm:ii format
-- @param {date} dateObj
Line 1,591:
put "-" after char 4 of str
return str
end</
<
-- parse string
Line 1,619:
-- show as YYYY-MM-DD hh:mm:ii string
put dateToDateTimeString(newDateObj)
-- "2009-03-08 07:30:00"</
=={{header|Lua}}==
The following solution is quite ugly, but unfortunately there is not anything like 'strptime'-function in Lua.
<
str = string.lower( "March 7 2009 7:30pm EST" )
Line 1,650:
print( os.date( "%c", os.time{ year=year, month=month, day=day, hour=hour, min=min, sec=0 } + 12 * 3600 ) )
</syntaxhighlight>
{{out}}
<pre>Sun Mar 8 07:30:00 2009</pre>
=={{header|Maple}}==
<
local dt, zone;
local months := ["January","February","March","April","May","June","July","August","September","October","November","December"];
Line 1,670:
printf(TimeZone(dt));
end proc;
</syntaxhighlight>
{{Out|Usage}}
<syntaxhighlight lang="text">twelve_hours("March 7 2009 7:30pm EST");
twelve_hours("March 2 2009 0:10am WET");
twelve_hours("March 2 2009 6:30am AST");</
{{Out|Output}}
<pre>
Line 1,683:
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
DateString[DatePlus[dstr, {12, "Hour"}], {"DayName", " ", "MonthName", " ", "Day", " ", "Year", " ", "Hour24", ":", "Minute", "AMPM"}]</
=={{header|mIRC Scripting Language}}==
<
=={{header|NetRexx}}==
<
options replace format comments java crossref symbols binary
Line 1,719:
end
return
</syntaxhighlight>
{{out}}
<pre>
Line 1,732:
We output the dates built after parsing in UTC. The module allows also to output in local time.
<
const Date = "March 7 2009 7:30pm EST"
Line 1,741:
dt = dt + initDuration(hours = 12)
echo "Date 12 hours later is: ", dt.utc().format("MMMM d yyyy h:mmtt zzz")</
{{out}}
Line 1,750:
=={{header|ooRexx}}==
===version 1===
<syntaxhighlight lang="oorexx">
sampleDate = 'March 7 2009 7:30pm EST'
Line 1,877:
*/
return
</syntaxhighlight>
===version 2===
This example is written using the Open Object Rexx dialect to take advantage of the <code>DateTime</code> built–in class.
<
sampleDate = 'March 7 2009 7:30pm EST'
Line 2,098:
__ENDD__
*/
</syntaxhighlight>
{{out}}
<pre>
Line 2,125:
We use Mountain Daylight Time for output.
<
use DateTime::Format::Strptime 'strptime';
use feature 'say';
Line 2,135:
->add(hours => 12)
->set_time_zone('America/Edmonton')
->format_cldr('MMMM d yyyy h:mma zzz');</
If we're given an ambiguous timezone like 'EST' for input, we can handle this by changing it to the unambiguous Olson timezone id. This ensures daylight savings is correctly handled (which is especially tricky here, since March 7/8 is the DST rollover, and times jump ahead skipping an hour)
Line 2,144:
=={{header|Phix}}==
{{libheader|Phix/basics}}
<!--<
<span style="color: #008080;">include</span> <span style="color: #000000;">builtins<span style="color: #0000FF;">\<span style="color: #004080;">timedate<span style="color: #0000FF;">.<span style="color: #000000;">e</span>
<span style="color: #7060A8;">set_timedate_formats<span style="color: #0000FF;">(<span style="color: #0000FF;">{<span style="color: #008000;">"Mmmm d yyyy h:mmpm tz"<span style="color: #0000FF;">}<span style="color: #0000FF;">)</span>
Line 2,155:
<span style="color: #000000;">td</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">adjust_timedate<span style="color: #0000FF;">(<span style="color: #000000;">td<span style="color: #0000FF;">,<span style="color: #7060A8;">timedelta<span style="color: #0000FF;">(<span style="color: #000000;">days<span style="color: #0000FF;">:=<span style="color: #000000;">31<span style="color: #0000FF;">*<span style="color: #000000;">4<span style="color: #0000FF;">)<span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?<span style="color: #7060A8;">format_timedate<span style="color: #0000FF;">(<span style="color: #000000;">td<span style="color: #0000FF;">)
<!--</
{{out}}
<pre>
Line 2,164:
=={{header|PHP}}==
<
$time = new DateTime('March 7 2009 7:30pm EST');
$time->modify('+12 hours');
echo $time->format('c');
?></
=={{header|PicoLisp}}==
<
(use (@Mon @Day @Year @Time @Zone)
(and
Line 2,189:
(dec '@Time 86400)
(inc 'Date) )
(pack (dat$ Date "-") " " (tim$ @Time T) " " @Zone) ) ) ) )</
=={{header|Pike}}==
<
Result: "Saturday, 7 March 2009 12:30:00"</
=={{header|PL/I}}==
<
/* different formats, but not that particular one. For any of the */
/* standard formats, the following date manipulation will add */
Line 2,203:
seconds = SECS(DATETIME());
seconds = seconds + 12*60*60;
put list (SECSTODATE(seconds));</
=={{header|PowerShell}}==
The .NET framework does not support parsing of time zone identifiers like "EST". We have to use time zone offsets like "-5".
<
write-host $date
write-host $date.AddHours(12)
write-host [TimeZoneInfo]::ConvertTimeBySystemTimeZoneId($date.AddHours(12),"Vladivostok Standard Time")</
{{out}} (depends on user regional settings):
<pre>domingo, 08 de marzo de 2009 1:30:00
Line 2,217:
=={{header|PureBasic}}==
<syntaxhighlight lang="purebasic">
EnableExplicit
Line 2,316:
CloseConsole()
EndIf
</syntaxhighlight>
{{out}}
Line 2,328:
I don't do anything with timezone here, but it is possible.
<
def mt():
Line 2,339:
print datime2.strftime("%B %d %Y %I:%M%p %Z") + datime1[-3:]
mt()</
=={{header|R}}==
<
isotime <- ISOdatetime(1900 + time$year, time$mon, time$mday,
time$hour, time$min, time$sec, "EST") # "2009-02-07 19:30:00 EST"
twelvehourslater <- isotime + 12 * 60 * 60 # "2009-02-08 07:30:00 EST"
timeincentraleurope <- format(isotime, tz="CET", usetz=TRUE) #"2009-02-08 01:30:00 CET"</
=={{header|Racket}}==
The solution below ignores the time zone.
<
#lang racket
(require srfi/19)
Line 2,368:
12hours))
"~a ~d ~b ~Y ~H:~M")
</syntaxhighlight>
{{out}}
<
"Sun 08 Mar 2009 07:30"
</syntaxhighlight>
=={{header|Raku}}==
Line 2,383:
or maybe just due to laziness), but that just gives us another opportunity to demonstrate the built-in grammar support.
<syntaxhighlight lang="raku"
my %month = flat (@month Z=> ^12), (@month».substr(0,3) Z=> ^12), 'Sept' => 8;
Line 2,434:
say "12 hours later, GMT: $dt";
say "12 hours later, PST: $dt.in-timezone(-8 * 3600)";</
{{out}}
<pre>12 hours later, GMT: 2009-02-08T12:30:00Z
Line 2,440:
=={{header|REBOL}}==
<
Title: "Date Manipulation"
URL: http://rosettacode.org/wiki/Date_Manipulation
Line 2,464:
print 12:00 + read-time "March 7 2009 7:30pm EST"
</syntaxhighlight>
{{out}}
Line 2,470:
=={{header|Red}}==
<syntaxhighlight lang="red">
d: 07-Mar-2009/19:30 + 12:00
print d
Line 2,476:
d/timezone: 1
print d
8-Mar-2009/8:30:00+01:00</
=={{header|REXX}}==
This version only works with REXXes that support the '''date''' and '''time''' extended functions.
<
aDate = 'March 7 2009 7:30pm EST' /*the original or base date to be used.*/
Line 2,495:
say aDate ' + 12 hours ───► ' ndate ntime tz /*display the new timestamp to console.*/
/*stick a fork in it, we're all done. */</
'''output'''
<pre>
Line 2,502:
=={{header|Ring}}==
<
# Project : Date manipulation
Line 2,529:
see "Original - " + dateorigin + nl
see "Manipulated - " + d + " " + t1 + ap + nl
</syntaxhighlight>
Output:
<pre>
Line 2,541:
{{libheader|ActiveSupport}}
<
d = "March 7 2009 7:30pm EST"
t = Time.parse(d)
Line 2,558:
# or, remote = new.in_time_zone('Beijing')
puts remote.rfc2822
puts remote.zone</
{{out}}
<pre>Sat, 07 Mar 2009 19:30:00 -0500
Line 2,568:
Using [[:Category:ActiveSupport|ActiveSupport]], we can add 12 hours with any of:
<
new = t.in(12.hours)
new = t.advance(:hours => 12)</
===DateTime class===
<
puts d1 = DateTime.parse("March 7 2009 7:30pm EST")
# d1 + 1 would add a day, so add half a day:
puts d2 = d1 + 1/2r # 1/2r is a rational; 0.5 would also work
puts d3 = d2.new_offset('+09:00')</
{{out}}
<pre>
Line 2,587:
=={{header|Run BASIC}}==
<
monthName$ = "January February March April May June July August September October November December"
Line 2,604:
ap$ = "am"
end if
print date$(d);" ";t1$;ap$</
=={{header|Rust}}==
<
use chrono::prelude::*;
use chrono::Duration;
Line 2,632:
}
</syntaxhighlight>
{{out}}
<pre>
Line 2,640:
</pre>
=={{header|Scala}}==
<
import java.util.{Calendar, Locale, TimeZone}
Line 2,656:
println(df.format(c.getTime))
}
}</
{{out}}
Line 2,670:
In the example below EST is replaced with UTC-05.
<
include "time.s7i";
include "duration.s7i";
Line 2,715:
aTime := toUTC(aTime);
writeln("In UTC: " <& aTime);
end func;</
{{out}}
Line 2,725:
=={{header|SenseTalk}}==
<
insert "[month name] [day] [year] [hour12]:[min][pm] [timeZoneID]" into the timeInputFormat
put date + 12 hours
</syntaxhighlight>
Output:
<
=={{header|Sidef}}==
{{trans|Perl}}
<
var input = 'March 7 2009 7:30pm EST'
Line 2,743:
.add(hours => 12) \
.set_time_zone('America/Edmonton') \
.format_cldr('MMMM d yyyy h:mma zzz')</
{{out}}
<pre>March 8 2009 6:30AM MDT</pre>
Line 2,756:
The code also fails when adding a duration that "jumps" beyond two DST changes (e.g from EST to EDT and EST again); (it could be partially fixed by considering intervals instead of single date, and adding a fourth element to link to the "new" timezone abbreviation)
<
setYear: aNum [ year := aNum ]
].
Line 2,805:
dateTime: aDT [ dateAndTime := aDT ]
].</
Usage example (note: the code is rather rigid, so not all operations possible on DateTime are possible on DateTimeTZ).
<
s := 'March 7 2009 7:30pm EST'.
Line 2,837:
}) displayNl.
(dt dateTime) asUTC displayNl.</
{{out}} (note that EST should be EDT):
Line 2,845:
=={{header|SQL}}==
{{works with|Oracle}}
<
-- March 7 2009 7:30pm EST
Line 2,878:
at time zone 'US/Arizona' plus_12_nodst
from dual;
</syntaxhighlight>
<pre>
Line 2,898:
=={{header|Standard ML}}==
<syntaxhighlight lang="standard ml">
val smltime= fn input => (* parse given format *)
let
Line 2,920:
(Date.fromTimeLocal o Time.fromReal)( ( date2real from) + hours * onehour );
end;
</syntaxhighlight>
output
<syntaxhighlight lang="standard ml">
hoursFrom 12.0 ( smltime "March 7 2009 7:30pm EST" ) ;
val it = Sun Mar 08 07:30:00 2009: Date.date
</syntaxhighlight>
=={{header|Swift}}==
<
let formatter = DateFormatter()
Line 2,940:
print(formatter.string(from: date))
print(formatter.string(from: date + 60 * 60 * 12))</
{{out}}
Line 2,949:
=={{header|Tcl}}==
{{works with|Tcl|8.5}}
<
set epoch [clock scan $date -format "%B %d %Y %I:%M%p %z"]
set later [clock add $epoch 12 hours]
puts [clock format $later] ;# Sun Mar 08 08:30:00 EDT 2009
puts [clock format $later -timezone :Asia/Shanghai] ;# Sun Mar 08 20:30:00 CST 2009</
Note the transition into daylight savings time in the interval (in the Eastern timezone).
Line 2,959:
=={{header|UNIX Shell}}==
requires GNU date
<
date -d @$epoch
TZ=Asia/Shanghai date -d @$epoch</
{{out}}
Line 2,969:
=={{header|Wren}}==
{{libheader|Wren-date}}
<
var fmt = "mmmm| |d| |yyyy| |H|:|MM|am| |zz|"
Line 2,979:
// Adjust to MST say
d = d.adjustTime("MST")
System.print("Adjusted to MST : %(d)")</
{{out}}
Line 2,990:
=={{header|zkl}}==
The iso8601 library offers additional Time/Date support but using the built in stuff:
<
fcn add12h(dt){
re:=RegExp(0'|(\w+)\s+(\d+)\s+(\d+)\ +(.+)\s|);
Line 3,000:
Y,M,D, h,m,s=Date.addHMS(dti,12);
"%s %d %d %s".fmt(Date.monthNames[M],D,Y,Date.toAMPMString(h,m));
}</
<
{{out}}
<pre>March 8 2009 07:30AM</pre>
|