Date manipulation: Difference between revisions

As extra credit, display the resulting time in a time zone different from your own.

<br><br>

 

=={{header|Ada}}==

Only standard libraries are required.

 

with Ada.Calendar.Formatting;

with Ada.Calendar.Time_Zones;

Put_Line ("T1 => " & Img (T1, EST) & " = " & Img (T1, Lisbon));

Put_Line ("T2 => " & Img (T2, EST) & " = " & Img (T2, Lisbon));

 

Result:

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

 

Result is:

 

=={{header|AutoHotkey}}==

 

; split the given string with RegExMatch

Result := "12"

Return, Result

{{out|Message box shows}}

<pre>Given: March 7 2009 7:30pm EST

 

=={{header|AWK}}==

# syntax: GAWK -f DATE_MANIPULATION.AWK

BEGIN {

exit(0)

}

{{out}}

<pre>

 

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

@echo off

 

echo Manipulated - %monthname% %day% %year% %hour%:%minutes%%ampm% %timezone%

exit /b

The code takes 3 inputs to demonstrate the ability to deal with leap years.

 

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

{{works with|BBC BASIC for Windows}}

date$ = "March 7 2009 7:30pm EST"

\ ":" + RIGHT$("0"+STR$(mins%), 2) + ampm$ + " " + zone$

ENDPROC

{{out}}

<pre>March 8 2009 7:30am EST

=={{header|C}}==

{{works with|POSIX}}

#include <stdlib.h>

#include <time.h>

 

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)

Console.ReadLine();

}

 

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

 

compiled with g++ -lboost_date_time

#include <iostream>

#include <boost/date_time/local_time/local_time.hpp>

return 0 ;

}

{{out}}

<pre>

 

=={{header|Clojure}}==

java.text.SimpleDateFormat)

 

long

(Date. ,)

 

=={{header|COBOL}}==

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.

 

.

end program date-manipulation.

 

{{out}}

2009-03-08/07:30:00-05:00

</pre>

 

=={{header|D}}==

import std.stdio;

import std.format;

}

 

{{out}}

<pre>

 

=={{header|Delphi}}==

program DateManipulation;

 

Readln;

end.

 

{{out}}

 

=={{header|EchoLisp}}==

(define my-date (string->date "March 7 2009 7:30 pm EST"))

→ Sun Mar 08 2009 01:30:00 GMT+0100 (CET)

(date->string my-date)

→ "8/3/2009 13:30:00" ;; human localized, Paris time.

 

----

=={{header|Erlang}}==

It is human readable to me.

-module( date_manipulation ).

 

time_from_strings_hour( Hour, "am" ) -> erlang:list_to_integer( Hour );

time_from_strings_hour( Hour, "pm" ) -> erlang:list_to_integer( Hour ) + 12.

{{out}}

<pre>

 

=={{header|Euphoria}}==

--Date Manipulation task from Rosetta Code wiki

--User:Lnettnay

dt = add(dt, 12, HOURS)

printf(1, "%s EST\n", {format(dt, "%B %d %Y %I:%M %p")})

{{out}}

<pre>

The .NET framework does not support parsing of time zone identifiers like "EST". We have to use time zone offsets like "-5".

 

 

let main() =

Console.WriteLine( "12 hours later in EST : {0}", date2_est )

 

 

{{out}} (depends on locale settings):

 

=={{header|Factor}}==

combinators io kernel math math.parser sequences splitting

unicode ;

 

"March 7 2009 7:30pm EST" parse-date dup 12 hours time+

{{out}}

<pre>

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

fansh> (d+12hr).toTimeZone(TimeZone("London")) // the extra credit!

2009-03-08T12:30:00Z London

 

=={{header|FreeBASIC}}==

 

#include "vbcompat.bi"

Print

Print "Press any key to quit"

 

{{out}}

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

 

{{out}}

 

=={{header|FunL}}==

 

pattern = SimpleDateFormat( 'MMMM d yyyy h:mma zzz' )

println( pattern.format(later) ) // Eastern Daylight Time

pattern.setTimeZone( TimeZone.getTimeZone('America/Los_Angeles') )

 

{{out}}

March 8 2009 8:30AM EDT

March 8 2009 5:30AM PDT

</pre>

 

=={{header|Go}}==

 

import (

fmt.Println("+12 hrs in Arizona:", t.In(atz))

}

{{out}}

<pre>

{{libheader|Joda Time|2.1}}

 

import java.text.*

 

println (dt)

println (dt.plusHours(12))

 

{{out}}

=={{header|Haskell}}==

 

 

main = print t2

 

=={{header|HicEst}}==

CHARACTER date="March 7 2009 7:30pm EST", am_pm, result*20

 

! result = "Sun 2009-03-08 07:30"

END

 

=={{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()

}

return case x of { "list" : AZ ; "table" : TZ }

 

{{libheader|Icon Programming Library}}

With that in mind:

 

months=: <;._2 tolower 0 :0

January

getts=: getyear, getmonth, getday, gethour, getminsec

timeadd=: 1&tsrep@+&tsrep

 

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

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'

 

Note that the isotimestamp representation uses a space instead of a 'T' to separate date and time.

 

=={{header|Java}}==

 

 

 

{{out}}

 

=={{header|JavaScript}}==

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

'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

 

{{out}}

 

=={{header|Julia}}==

 

function main()

end

 

<pre>March 08 2009 07:30</pre>

 

=={{header|Kotlin}}==

 

import java.text.SimpleDateFormat

cal.timeZone = TimeZone.getTimeZone("MST")

println(fmt.format(cal))

 

{{out}}

March 08 2009 7:30am EST

March 08 2009 5:30am MST

</pre>

 

=={{header|Lasso}}==

#date->add(-hour = 24)

 

{{out}}

 

=={{header|Lingo}}==

-- Returns string representation of given date object in YYYY-MM-DD hh:mm:ii format

-- @param {date} dateObj

put "-" after char 4 of str

return str

 

 

-- parse string

-- show as YYYY-MM-DD hh:mm:ii string

put dateToDateTimeString(newDateObj)

 

=={{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" )

 

 

print( os.date( "%c", os.time{ year=year, month=month, day=day, hour=hour, min=min, sec=0 } + 12 * 3600 ) )

{{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"];

printf(TimeZone(dt));

end proc;

{{Out|Usage}}

twelve_hours("March 2 2009 0:10am WET");

{{Out|Output}}

<pre>

 

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

 

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

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols binary

 

end

return

{{out}}

<pre>

 

=={{header|Nim}}==

 

{{out}}

 

=={{header|ooRexx}}==

===version 1===

sampleDate = 'March 7 2009 7:30pm EST'

 

*/

return

 

===version 2===

This example is written using the Open Object Rexx dialect to take advantage of the <code>DateTime</code> built&ndash;in class.

sampleDate = 'March 7 2009 7:30pm EST'

 

__ENDD__

*/

{{out}}

<pre>

We use Mountain Daylight Time for output.

 

use DateTime::Format::Strptime 'strptime';

use feature 'say';

->add(hours => 12)

->set_time_zone('America/Edmonton')

 

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)

{{out}}

<pre>March 8 2009 6:30AM MDT</pre>

 

=={{header|Phix}}==

{{out}}

<pre>

 

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

(dec '@Time 86400)

(inc 'Date) )

 

=={{header|Pike}}==

 

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

/* different formats, but not that particular one. For any of the */

/* standard formats, the following date manipulation will add */

seconds = SECS(DATETIME());

seconds = seconds + 12*60*60;

 

=={{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)

{{out}} (depends on user regional settings):

<pre>domingo, 08 de marzo de 2009 1:30:00

 

=={{header|PureBasic}}==

EnableExplicit

 

CloseConsole()

EndIf

 

{{out}}

I don't do anything with timezone here, but it is possible.

 

 

def mt():

print datime2.strftime("%B %d %Y %I:%M%p %Z") + datime1[-3:]

 

 

=={{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"

 

=={{header|Racket}}==

The solution below ignores the time zone.

#lang racket

(require srfi/19)

12hours))

"~a ~d ~b ~Y ~H:~M")

{{out}}

"Sun 08 Mar 2009 07:30"

 

=={{header|REBOL}}==

Title: "Date Manipulation"

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

 

print 12:00 + read-time "March 7 2009 7:30pm EST"

 

{{out}}

 

=={{header|Red}}==

d: 07-Mar-2009/19:30 + 12:00

print d

d/timezone: 1

print d

 

=={{header|REXX}}==

This version only works with REXXes that support the &nbsp; '''date''' &nbsp; and &nbsp; '''time''' &nbsp; extended functions.

aDate = 'March 7 2009 7:30pm EST' /*the original or base date to be used.*/

 

 

say aDate ' + 12 hours ───► ' ndate ntime tz /*display the new timestamp to console.*/

'''output'''

<pre>

 

=={{header|Ring}}==

# Project : Date manipulation

 

see "Original - " + dateorigin + nl

see "Manipulated - " + d + " " + t1 + ap + nl

Output:

<pre>

Original - March 7 2009 7:30pm EST

Manipulated - 08/03/2009 7:30am

</pre>

 

 

{{libheader|ActiveSupport}}

d = "March 7 2009 7:30pm EST"

t = Time.parse(d)

# or, remote = new.in_time_zone('Beijing')

puts remote.rfc2822

{{out}}

<pre>Sat, 07 Mar 2009 19:30:00 -0500

 

Using [[:Category:ActiveSupport|ActiveSupport]], we can add 12 hours with any of:

new = t.in(12.hours)

 

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

{{out}}

<pre>

 

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

 

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

ap$ = "am"

end if

 

=={{header|Scala}}==

import java.util.{Calendar, Locale, TimeZone}

 

println(df.format(c.getTime))

}

 

{{out}}

<pre>March 8 2009 8:30AM EDT

March 8 2009 12:30PM GMT</pre>

 

=={{header|Seed7}}==

In the example below EST is replaced with UTC-05.

 

include "time.s7i";

include "duration.s7i";

aTime := toUTC(aTime);

writeln("In UTC: " <& aTime);

 

{{out}}

In UTC: 2009-03-09 00:30:00 UTC

</pre>

 

=={{header|Sidef}}==

{{trans|Perl}}

 

var input = 'March 7 2009 7:30pm EST'

.add(hours => 12) \

.set_time_zone('America/Edmonton') \

{{out}}

<pre>March 8 2009 6:30AM MDT</pre>

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 ]

].

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

}) displayNl.

 

 

{{out}} (note that EST should be EDT):

=={{header|SQL}}==

{{works with|Oracle}}

-- March 7 2009 7:30pm EST

 

at time zone 'US/Arizona' plus_12_nodst

from dual;

 

<pre>

08-MAR-09 05.30.00.000000000 AM US/ARIZONA

</pre>

 

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

 

Note the transition into daylight savings time in the interval (in the Eastern timezone).

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

requires GNU date

date -d @$epoch

 

{{out}}

<pre>Sun Mar 8 08:30:00 EDT 2009

Sun Mar 8 20:30:00 CST 2009</pre>

 

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

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>