What mode for MySQL&#39;s [`WEEK()`][1] function yields the [ISO 8601 week of the year][2]?  Argument 2 of `WEEK()` sets the mode according to this chart:

    +--------------------------------------------------------------------+
    | Mode | First day of week | Range | Week 1 is the first week ...    |
    |------+-------------------+-------+---------------------------------|
    | 0    | Sunday            | 0-53  | with a Sunday in this year      |
    |------+-------------------+-------+---------------------------------|
    | 1    | Monday            | 0-53  | with more than 3 days this year |
    |------+-------------------+-------+---------------------------------|
    | 2    | Sunday            | 1-53  | with a Sunday in this year      |
    |------+-------------------+-------+---------------------------------|
    | 3    | Monday            | 1-53  | with more than 3 days this year |
    |------+-------------------+-------+---------------------------------|
    | 4    | Sunday            | 0-53  | with more than 3 days this year |
    |------+-------------------+-------+---------------------------------|
    | 5    | Monday            | 0-53  | with a Monday in this year      |
    |------+-------------------+-------+---------------------------------|
    | 6    | Sunday            | 1-53  | with more than 3 days this year |
    |------+-------------------+-------+---------------------------------|
    | 7    | Monday            | 1-53  | with a Monday in this year      |
    +--------------------------------------------------------------------+

Will one of these modes give the ISO 8601 week of the year?


  [1]: http://dev.mysql.com/doc/refman/5.5/en/date-and-time-functions.html#function_week
  [2]: http://en.wikipedia.org/wiki/ISO_week_date

What mode for MySQL WEEK() complies with ISO 8601

how can i sort this array by date (ISO 8601)?

    var myArray = new Array();
    
    myArray[0] = { name:&#39;oldest&#39;, date:&#39;2007-01-17T08:00:00Z&#39; }
    myArray[1] = { name:&#39;newest&#39;, date:&#39;2011-01-28T08:00:00Z&#39; }
    myArray[2] = { name:&#39;old&#39;,    date:&#39;2009-11-25T08:00:00Z&#39; }

**Playground:**&lt;br /&gt;
http://jsfiddle.net/4tUZt/

Thanks in advance!








Sort array by ISO 8601 date

I have a DateTime string ISO8601 formated

    2012-10-06T04:13:00+00:00

and the following Regex which does not match this string

    #(\d{4})-(\d{2})-(\d{2})T(\d{2})\:(\d{2})\:(\d{2})\+(\d{2})\:(\d{2})#

I can&#39;t figure out why it does not match.

I escaped metacharacters, for me it seems to be OK.

http://jsfiddle.net/5n5vk/2/

**EDIT :**

The right way: http://jsfiddle.net/5n5vk/3/

Regex and ISO8601 formatted DateTime

I&#39;m trying to format a Postgres date representation into a ISO 8601 string. I&#39;m assuming that there is a Postgres function that can do it, but I found the documentation short on examples. 

My query is 

    SELECT
      now()::timestamp

which returns

    [{{2016, 8, 9}, {3, 56, 55, 754181}}]

I&#39;m trying to get the date into a format that looks more like 
`2016-8-9T03:56:55+00:00`. 

What changes do I need to make to my query to make that happen? Thanks for your help.

Turn postgres date representation into ISO 8601 string

I have a string in standard [ISO 8601][1] format that contains the date/time returned from a web service like so:

    String dtStart = &quot;2010-10-15T09:27:37Z&quot;

How do I get this into an object such as Time or Date? I initially want to output it in a different format, but will need to do other stuff with it later (i.e. maybe use in a different format).

Cheers


  [1]: https://en.wikipedia.org/wiki/ISO_8601

ISO 8601 String to Date/Time object in Android

I have a `Date` object. **How do I render the `title` portion of the following snippet?**

    &lt;abbr title=&quot;2010-04-02T14:12:07&quot;&gt;A couple days ago&lt;/abbr&gt;

_I have the &quot;relative time in words&quot; portion from another library._

I&#39;ve tried the following:

    function isoDate(msSinceEpoch) {

       var d = new Date(msSinceEpoch);
       return d.getUTCFullYear() + &#39;-&#39; + (d.getUTCMonth() + 1) + &#39;-&#39; + d.getUTCDate() + &#39;T&#39; +
              d.getUTCHours() + &#39;:&#39; + d.getUTCMinutes() + &#39;:&#39; + d.getUTCSeconds();

    }

But that gives me:

    &quot;2010-4-2T3:19&quot;


How do I output an ISO 8601 formatted string in JavaScript?

I pick some date and time in javascript and then want to store it on server (.NET). Dates are supposed to be in future from the current moment (so they won&#39;t be before 1970).
Having read topics here on SO I learnt it&#39;s better to store date as a string and people suggest using `Date.prototype.toISOString()` or `Date.prototype.toUTCString()`. 
I&#39;ve read that `toISOString()` is not available in IE 7. And I&#39;d like to know other differences, when I should choose one or another function.

What&#39;s the difference between datetime in ISO 8601 and UTC formats in javascript?

This docs mention `moment.ISO_8601` as a formatting option (from 2.7.0 - http://momentjs.com/docs/#/parsing/special-formats/), but neither of these work (even 2.7.0):

    var date = moment();
    date.format(moment.ISO_8601); // error
    moment.format(date, moment.ISO_8601); // error

(http://jsfiddle.net/b3d6uy05/1/)

How can I get an ISO 8601 from moment.js?

How do I format a date as ISO 8601 in moment.js?

In a Bash script, I want to print the current datetime in [ISO 8601][1] format (preferably UTC), and it seems that this should be as simple as `date -I`:

http://ss64.com/bash/date.html

But this doesn&#39;t seem to work on my Mac:

    $ date -I
    date: illegal option -- I
    usage: date [-jnu] [-d dst] [-r seconds] [-t west] [-v[+|-]val[ymwdHMS]] ... 
                [-f fmt date | [[[mm]dd]HH]MM[[cc]yy][.ss]] [+format]

And indeed, `man date` doesn&#39;t list this option.

Anyone know why this is, or any other (easy) way for me to print the date in ISO 8601 format? Thanks!


  [1]: http://en.wikipedia.org/wiki/ISO_8601

`date` command on OS X doesn&#39;t have ISO 8601 `-I` option?

How to generate a date time stamp, using the format standards for [ISO 8601](http://en.wikipedia.org/wiki/ISO_8601) and [RFC 3339](https://www.rfc-editor.org/rfc/rfc3339)?

The goal is a string that looks like this:

    &quot;2015-01-01T00:00:00.000Z&quot;

Format:

  * year, month, day, as &quot;XXXX-XX-XX&quot;
  * the letter &quot;T&quot; as a separator
  * hour, minute, seconds, milliseconds, as &quot;XX:XX:XX.XXX&quot;.
  * the letter &quot;Z&quot; as a zone designator for zero offset, a.k.a. UTC, GMT, Zulu time.

Best case:

  * Swift source code that is simple, short, and straightforward.
  * No need to use any additional framework, subproject, cocoapod, C code, etc.

I&#39;ve searched StackOverflow, Google, Apple, etc. and haven&#39;t found a Swift answer to this. 

The classes that seem most promising are [`NSDate`](https://developer.apple.com/library/mac/documentation/Cocoa/Reference/Foundation/Classes/NSDate_Class/index.html), [`NSDateFormatter`](https://developer.apple.com/library/mac/documentation/Cocoa/Reference/Foundation/Classes/NSDateFormatter_Class/index.html), [`NSTimeZone`](https://developer.apple.com/library/mac/documentation/Cocoa/Reference/Foundation/Classes/NSTimeZone_Class/index.html).

Related Q&amp;A: https://stackoverflow.com/questions/16254575/how-do-i-get-iso-8601-date-in-ios

Here&#39;s the best I&#39;ve come up with so far:

    var now = NSDate()
    var formatter = NSDateFormatter()
    formatter.dateFormat = &quot;yyyy-MM-dd&#39;T&#39;HH:mm:ss.SSS&#39;Z&#39;&quot;
    formatter.timeZone = NSTimeZone(forSecondsFromGMT: 0)
    println(formatter.stringFromDate(now))



How can I parse / create a date time stamp formatted with fractional seconds UTC timezone (ISO 8601, RFC 3339) in Swift?

Given:

    DateTime.UtcNow

How do I get a string which represents the same value in an [ISO 8601][1]-compliant format?

Note that ISO 8601 defines a number of similar formats. The specific format I am looking for is:

    yyyy-MM-ddTHH:mm:ssZ

  [1]: http://en.wikipedia.org/wiki/ISO_8601


Given a DateTime object, how do I get an ISO 8601 date in string format?

I have a date string and I want to parse it to normal date use the java Date API,the following is my code:

	public static void main(String[] args) {
		String date=&quot;2010-10-02T12:23:23Z&quot;;
		String pattern=&quot;yyyy-MM-ddThh:mm:ssZ&quot;;
		SimpleDateFormat sdf=new SimpleDateFormat(pattern);
		try {
			Date d=sdf.parse(date);
			System.out.println(d.getYear());
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

However I got an exception: `java.lang.IllegalArgumentException: Illegal pattern character &#39;T&#39;`

So I wonder if I have to split the string and parse it manually?

BTW, I have tried to add a single quote character on either side of the T:   

    String pattern=&quot;yyyy-MM-dd&#39;T&#39;hh:mm:ssZ&quot;;

It also does not work.

Illegal pattern character &#39;T&#39; when parsing a date string to java.util.Date

Why python 2.7 doesn&#39;t include Z character (Zulu or zero offset) at the end of UTC datetime object&#39;s isoformat string unlike JavaScript?

    &gt;&gt;&gt; datetime.datetime.utcnow().isoformat()
    &#39;2013-10-29T09:14:03.895210&#39;

Whereas in javascript

    &gt;&gt;&gt;  console.log(new Date().toISOString()); 
    2013-10-29T09:38:41.341Z


Python UTC datetime object&#39;s ISO format doesn&#39;t include Z (Zulu or Zero offset)

I need to parse [RFC 3339][1] strings like `&quot;2008-09-03T20:56:35.450686Z&quot;` into Python&#39;s `datetime` type.

I have found [`strptime`][2] in the Python standard library, but it is not very convenient.

What is the best way to do this?

  [1]: https://www.rfc-editor.org/rfc/rfc3339
  [2]: https://docs.python.org/library/datetime.html#datetime.datetime.strptime



How do I parse an ISO 8601-formatted date?

I am trying to convert an [ISO 8601][1] formatted String to a `java.util.Date`. 

I found the pattern `yyyy-MM-dd&#39;T&#39;HH:mm:ssZ` to be ISO8601-compliant if used with a Locale (compare sample).

However, using the `java.text.SimpleDateFormat`, I cannot convert the correctly formatted String `2010-01-01T12:00:00+01:00`. I have to convert it first to `2010-01-01T12:00:00+0100`, without the colon. 

So, the current solution is

&lt;!-- language: lang-java --&gt;

    SimpleDateFormat ISO8601DATEFORMAT = new SimpleDateFormat(&quot;yyyy-MM-dd&#39;T&#39;HH:mm:ssZ&quot;, Locale.GERMANY);
    String date = &quot;2010-01-01T12:00:00+01:00&quot;.replaceAll(&quot;\\+0([0-9]){1}\\:00&quot;, &quot;+0$100&quot;);
    System.out.println(ISO8601DATEFORMAT.parse(date));

which obviously isn&#39;t that nice. Am I missing something or is there a better solution?


----------


**Answer**

Thanks to JuanZe&#39;s comment, I found the [Joda-Time][2] magic, it is also [described here][3].

So, the solution is

&lt;!-- language: lang-java --&gt;
     
    DateTimeFormatter parser2 = ISODateTimeFormat.dateTimeNoMillis();
    String jtdate = &quot;2010-01-01T12:00:00+01:00&quot;;
    System.out.println(parser2.parseDateTime(jtdate));

Or more simply, use the default parser via the constructor:

&lt;!-- language: lang-java --&gt;

    DateTime dt = new DateTime( &quot;2010-01-01T12:00:00+01:00&quot; ) ;

To me, this is nice.


  [1]: http://en.wikipedia.org/wiki/ISO_8601
  [2]: http://www.joda.org/joda-time/
  [3]: http://johannburkard.de/blog/programming/java/date-time-parsing-formatting-joda-time.html

Converting ISO 8601-compliant String to java.util.Date

I&#39;ve found how to turn a DateTime into an [ISO 8601][1] format, but nothing on how to do the reverse in C#.

I have `2010-08-20T15:00:00Z`, and I want to turn it into a `DateTime` object.

I could separate the parts of the string myself, but that seems like a lot of work for something that is already an international standard.

  [1]: https://en.wikipedia.org/wiki/ISO_8601


How to create a .NET DateTime from ISO 8601 format

It&#39;s easy enough to get the ISO 8601 date string (for example, `2004-02-12T15:19:21+00:00`) in PHP via `date(&#39;c&#39;)`, but how does one get it in Objective-C (iPhone)? Is there a similarly short way to do it?

Here&#39;s the *long* way I found to do it:

    NSDateFormatter* dateFormatter = [[[NSDateFormatter alloc] init] autorelease];
    dateFormatter.dateFormat = @&quot;yyyy-MM-dd&#39;T&#39;HH:mm:ssZ&quot;;

    NSDate *now = [NSDate date];
    NSString *formattedDateString = [dateFormatter stringFromDate:now];
    NSLog(@&quot;ISO-8601 date: %@&quot;, formattedDateString);

    // Output: ISO-8601 date: 2013-04-27T13:27:50-0700

It seems an awful lot of rigmarole for something so central.



How do I get an ISO 8601 date on iOS?

I have a file. In Python, I would like to take its creation time, and convert it to an [ISO time (ISO 8601) string][1] **while preserving the fact that it was created in the [Eastern Time Zone][2] (ET)**.

How do I take the file&#39;s ctime and convert it to an ISO time string that indicates the Eastern Time Zone (and takes into account daylight savings time, if necessary)?

  [1]: http://en.wikipedia.org/wiki/ISO_8601
  [2]: https://en.wikipedia.org/wiki/Eastern_Time_Zone


ISO time (ISO 8601) in Python

I need to parse an ISO8601 date/time format with an included timezone (from an external source) in Excel/VBA, to a normal Excel Date. As far as I can tell, Excel XP (which is what we&#39;re using) doesn&#39;t have a routine for that built-in, so I guess I&#39;m looking at a custom VBA function for the parsing.

ISO8601 datetimes look like one of these:

```none
2011-01-01
2011-01-01T12:00:00Z
2011-01-01T12:00:00+05:00
2011-01-01T12:00:00-05:00
2011-01-01T12:00:00.05381+05:00
```

Parsing an ISO8601 date/time (including TimeZone) in Excel

I&#39;m getting a datetime string in a format like &quot;2009-05-28T16:15:00&quot; (this is ISO 8601, I believe). One hackish option seems to be to parse the string using `time.strptime` and passing the first six elements of the tuple into the datetime constructor, like:

    datetime.datetime(*time.strptime(&quot;2007-03-04T21:08:12&quot;, &quot;%Y-%m-%dT%H:%M:%S&quot;)[:6])

I haven&#39;t been able to find a &quot;cleaner&quot; way of doing this. Is there one?



How do I translate an ISO 8601 datetime string into a Python datetime object?

So in Python 3, you can generate an ISO 8601 date with .isoformat(), but you can&#39;t convert a string created by isoformat() back into a datetime object because Python&#39;s own datetime directives don&#39;t match properly. That is, %z = 0500 instead of 05:00 (which is produced by .isoformat()).

For example:

    &gt;&gt;&gt; strDate = d.isoformat()
    &gt;&gt;&gt; strDate
    &#39;2015-02-04T20:55:08.914461+00:00&#39;

    &gt;&gt;&gt; objDate = datetime.strptime(strDate,&quot;%Y-%m-%dT%H:%M:%S.%f%z&quot;)
    Traceback (most recent call last):
      File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
      File &quot;C:\Python34\Lib\_strptime.py&quot;, line 500, in _strptime_datetime
        tt, fraction = _strptime(data_string, format)
      File &quot;C:\Python34\Lib\_strptime.py&quot;, line 337, in _strptime
        (data_string, format))
    ValueError: time data &#39;2015-02-04T20:55:08.914461+00:00&#39; does not match format &#39;%Y-%m-%dT%H:%M:%S.%f%z&#39;

From Python&#39;s strptime documentation: (https://docs.python.org/2/library/datetime.html#strftime-strptime-behavior)

&gt; %z    UTC offset in the form +HHMM or -HHMM (empty string if the the
&gt; object is naive).    (empty), +0000, -0400, +1030

So, in short, Python does not even adhere to its own string formatting directives.

I know datetime is already terrible in Python, but this really goes beyond unreasonable into the land of plain stupidity.

Tell me this isn&#39;t true.


How to convert Python&#39;s .isoformat() string back into datetime object

Here is a standard way to serialise date as ISO 8601 string in JavaScript:


&lt;!-- begin snippet: js hide: false console: true babel: false --&gt;

&lt;!-- language: lang-js --&gt;

    var now = new Date();
    console.log( now.toISOString() );
    // outputs &#39;2015-12-02T21:45:22.279Z&#39;

&lt;!-- end snippet --&gt;

I need just the same output, but without milliseconds. How can I output `2015-12-02T21:45:22Z` ?&amp;nbsp;

How to output date in javascript in ISO 8601 without milliseconds and with Z

I have a bunch of ISO-8601 formatted strings in a column of my sheet.  How can I get google sheets to treat them as Dates so I can do math on them (difference in minutes between two cells, for example)?  I tried just ```=Date(&quot;2015-05-27T01:15:00.000Z&quot;)``` but no-joy.  There has to be an easy way to do this.  Any advice?

ISO-8601 String to Date in Google Sheets cell

Need help/tips on converting an ISO 8601 date with the following structure into javascript.

    CCYY-MM-DDThh:mm:ssTZD

I&#39;d like to format the date like so:

    January 28, 2011 - 7:30PM EST

I&#39;d like to keep this solution as clean and minimal as possible.


Parsing ISO 8601 date in Javascript

I&#39;m trying to generate an [RFC 3339][1] UTC timestamp in Python. So far I&#39;ve been able to do the following:

    &gt;&gt;&gt; d = datetime.datetime.now()
    &gt;&gt;&gt; print d.isoformat(&#39;T&#39;)
    2011-12-18T20:46:00.392227

My problem is with setting the UTC offset.

According to the [docs][2], the classmethod `datetime.now([tz])`, takes an optional `tz` argument where `tz must be an instance of a class tzinfo subclass`, and `datetime.tzinfo` is `an abstract base class for time zone information objects.`

This is where I get lost- How come tzinfo is an abstract class, and how am I supposed to implement it? 

---

(**NOTE:** In PHP it&#39;s as simple as `timestamp = date(DATE_RFC3339);`, which is why I can&#39;t understand why Python&#39;s approach is so convoluted...)

  [1]: https://www.rfc-editor.org/rfc/rfc3339
  [2]: http://docs.python.org/library/datetime.html

Generate RFC 3339 timestamp in Python

In Python, how can I convert a string like this:

&gt; Thu, 16 Dec 2010 12:14:05 +0000

to ISO 8601 format, while keeping the timezone?

Please note that the orginal date is string, and the output should be string too, not `datetime` or something like that.

I have no problem to use third parties libraries, though.

Python - Convert string representation of date to ISO 8601

I have a date in the following format: &lt;code&gt;2010-03-01T00:00:00-08:00&lt;/code&gt;

I have thrown the following SimpleDateFormats at it to parse it:

    private static final SimpleDateFormat[] FORMATS = {
            new SimpleDateFormat(&quot;yyyy-MM-dd&#39;T&#39;HH:mm:ssZ&quot;), //ISO8601 long RFC822 zone
            new SimpleDateFormat(&quot;yyyy-MM-dd&#39;T&#39;HH:mm:ssz&quot;), //ISO8601 long long form zone
            new SimpleDateFormat(&quot;yyyy-MM-dd&#39;T&#39;HH:mm:ss&quot;), //ignore timezone
            new SimpleDateFormat(&quot;yyyyMMddHHmmssZ&quot;), //ISO8601 short
            new SimpleDateFormat(&quot;yyyyMMddHHmm&quot;),
            new SimpleDateFormat(&quot;yyyyMMdd&quot;), //birthdate from NIST IHE C32 sample
            new SimpleDateFormat(&quot;yyyyMM&quot;),
            new SimpleDateFormat(&quot;yyyy&quot;) //just the year
        };

I have a convenience method that uses those formats like so:

    public static Date figureOutTheDamnDate(String wtf) {
        if (wtf == null) {
            return null;
        }
        Date retval = null;
        for (SimpleDateFormat sdf : FORMATS) {
            try {
                sdf.setLenient(false)
                retval = sdf.parse(wtf);
                System.out.println(&quot;Date:&quot; + wtf + &quot; hit on pattern:&quot; + sdf.toPattern());
                break;
            } catch (ParseException ex) {
                retval = null;
                continue;
            }
        }
    
        return retval;
    }

It seems to hit on the pattern &lt;code&gt;yyyyMMddHHmm&lt;/code&gt; but returns the date as &lt;code&gt;Thu Dec 03 00:01:00 PST 2009&lt;/code&gt;.

What is the correct pattern to parse this date? 

UPDATE: I don&#39;t NEED the time zone parsing. I don&#39;t anticipate having time sensitive issues moving between zones, but how would I get the &quot;-08:00&quot; zone format to parse????

Unit test:

    @Test
    public void test_date_parser() {
        System.out.println(&quot;\ntest_date_parser&quot;);
        //month is zero based, are you effing kidding me
        Calendar d = new GregorianCalendar(2000, 3, 6, 13, 00, 00);
        assertEquals(d.getTime(), MyClass.figureOutTheDamnDate(&quot;200004061300&quot;));
        assertEquals(new GregorianCalendar(1950, 0, 1).getTime(), MyClass.figureOutTheDamnDate(&quot;1950&quot;));
        assertEquals(new GregorianCalendar(1997, 0, 1).getTime(),  MyClass.figureOutTheDamnDate(&quot;199701&quot;));
        assertEquals(new GregorianCalendar(2010, 1, 25, 15, 19, 44).getTime(),   MyClass.figureOutTheDamnDate(&quot;20100225151944-0800&quot;));
    
        //my machine happens to be in GMT-0800
        assertEquals(new GregorianCalendar(2010, 1, 15, 13, 15, 00).getTime(),MyClass.figureOutTheDamnDate(&quot;2010-02-15T13:15:00-05:00&quot;));
        assertEquals(new GregorianCalendar(2010, 1, 15, 18, 15, 00).getTime(), MyClass.figureOutTheDamnDate(&quot;2010-02-15T18:15:00-05:00&quot;));
    
        assertEquals(new GregorianCalendar(2010, 2, 1).getTime(), MyClass.figureOutTheDamnDate(&quot;2010-03-01T00:00:00-08:00&quot;));
        assertEquals(new GregorianCalendar(2010, 2, 1, 17, 0, 0).getTime(), MyClass.figureOutTheDamnDate(&quot;2010-03-01T17:00:00-05:00&quot;));
    }

Output from unit test:

    test_date_parser
    Date:200004061300 hit on pattern:yyyyMMddHHmm
    Date:1950 hit on pattern:yyyy
    Date:199701 hit on pattern:yyyyMM
    Date:20100225151944-0800 hit on pattern:yyyyMMddHHmmssZ
    Date:2010-02-15T13:15:00-05:00 hit on pattern:yyyy-MM-dd&#39;T&#39;HH:mm:ss
    Date:2010-02-15T18:15:00-05:00 hit on pattern:yyyy-MM-dd&#39;T&#39;HH:mm:ss
    Date:2010-03-01T00:00:00-08:00 hit on pattern:yyyy-MM-dd&#39;T&#39;HH:mm:ss
    Date:2010-03-01T17:00:00-05:00 hit on pattern:yyyy-MM-dd&#39;T&#39;HH:mm:ss



Java SimpleDateFormat for time zone with a colon separator?

I&#39;m trying to grab the date from my database in a standard timestamp and display it as ISO 8601.  I&#39;m unable to easily do it in PHP so I&#39;m trying to do it in my SELECT statement.  This is what I have, but it displays an error:

    SELECT * FROM table_name ORDER BY id DESC DATE_FORMAT(date,&quot;%Y-%m-%dT%TZ&quot;)
What am I doing wrong?

Format date in MySQL SELECT as ISO 8601

I need to display and handle UTC dates in the following format:

&gt; 2013-06-28T22:15:00Z

As this format is part of the ISO8601 standard I have no trouble creating DateTime objects from strings like the one above. However I can&#39;t find a clean way (meaning no string manipulations like substr and replace, etc.) to present my DateTime object in the desired format. I tried to tweak the server and php datetime settings, with little success. I always get:

    $date-&gt;format(DateTime::ISO8601); // gives 2013-06-28T22:15:00+00:00

Is there any date format or configuration setting that will give me the desired string? Or I&#39;ll have to append the &#39;Z&#39; manually to a custom time format?

How to format an UTC date to use the Z (Zulu) zone designator in php?

I am trying to use the `Duration` class instead of `long`. 
It has superior literal syntax. I like its flexibility, though it looks weird.

&quot;PT10S&quot; means 10 seconds, what is the problem to accept &quot;10 seconds&quot;?!
Okay never mind.

I am just curious why PT prefix has been chosen (not &quot;DU&quot; e.g.) and why any prefix is better here rather than nothing?
 

All Iso8601 Solutions on Gang of Coders

Total of 30 Iso8601 Solutions