Remember to set the locale to en_US_POSIX as described in Technical Q&A1480. In Swift 3:

let date = Date()

let formatter = DateFormatter()

formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSZZZZZ"

formatter.timeZone = TimeZone(secondsFromGMT: 0)

formatter.locale = Locale(identifier: "en_US_POSIX")

print(formatter.string(from: date))

The issue is that if you're on a device which is using a non-Gregorian calendar, the year will not conform to RFC3339/ISO8601 unless you specify the locale as well as the timeZone and dateFormat string.

Or you can use ISO8601DateFormatter to get you out of the weeds of setting locale and timeZone yourself:

let date = Date()

let formatter = ISO8601DateFormatter()

formatter.formatOptions.insert(.withFractionalSeconds)  // this is only available effective iOS 11 and macOS 10.13

print(formatter.string(from: date))

For Swift 2 rendition, see previous revision of this answer.

If you want to use the ISO8601DateFormatter() with a date from a Rails 4+ JSON feed (and don't need millis of course), you need to set a few options on the formatter for it to work right otherwise the the date(from: string) function will return nil. Here's what I'm using:

extension Date {

    init(dateString:String) {

        self = Date.iso8601Formatter.date(from: dateString)!

    }



    static let iso8601Formatter: ISO8601DateFormatter = {

        let formatter = ISO8601DateFormatter()

        formatter.formatOptions = [.withFullDate,

                                          .withTime,

                                          .withDashSeparatorInDate,

                                          .withColonSeparatorInTime]

        return formatter

    }()

}

Here's the result of using the options verses not in a playground screenshot:

To further compliment Andrés Torres Marroquín and Leo Dabus, I have a version that preserves fractional seconds. I can't find it documented anywhere, but Apple truncate fractional seconds to the microsecond (3 digits of precision) on both input and output (even though specified using SSSSSSS, contrary to Unicode tr35-31).

I should stress that this is probably not necessary for most use cases. Dates online do not typically need millisecond precision, and when they do, it is often better to use a different data format. But sometimes one must interoperate with a pre-existing system in a particular way.

Xcode 8/9 and Swift 3.0-3.2

extension Date {

    struct Formatter {

        static let iso8601: DateFormatter = {

            let formatter = DateFormatter()

            formatter.calendar = Calendar(identifier: .iso8601)

            formatter.locale = Locale(identifier: "en_US_POSIX")

            formatter.timeZone = TimeZone(identifier: "UTC")

            formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSXXXXX"

            return formatter

        }()

    }



    var iso8601: String {

        // create base Date format 

         var formatted = DateFormatter.iso8601.string(from: self)



        // Apple returns millisecond precision. find the range of the decimal portion

         if let fractionStart = formatted.range(of: "."),

             let fractionEnd = formatted.index(fractionStart.lowerBound, offsetBy: 7, limitedBy: formatted.endIndex) {

             let fractionRange = fractionStart.lowerBound..<fractionEnd

            // replace the decimal range with our own 6 digit fraction output

             let microseconds = self.timeIntervalSince1970 - floor(self.timeIntervalSince1970)

             var microsecondsStr = String(format: "%.06f", microseconds)

             microsecondsStr.remove(at: microsecondsStr.startIndex)

             formatted.replaceSubrange(fractionRange, with: microsecondsStr)

        }

         return formatted

    }

}



extension String {

    var dateFromISO8601: Date? {

        guard let parsedDate = Date.Formatter.iso8601.date(from: self) else {

            return nil

        }



        var preliminaryDate = Date(timeIntervalSinceReferenceDate: floor(parsedDate.timeIntervalSinceReferenceDate))



        if let fractionStart = self.range(of: "."),

            let fractionEnd = self.index(fractionStart.lowerBound, offsetBy: 7, limitedBy: self.endIndex) {

            let fractionRange = fractionStart.lowerBound..<fractionEnd

            let fractionStr = self.substring(with: fractionRange)



            if var fraction = Double(fractionStr) {

                fraction = Double(floor(1000000*fraction)/1000000)

                preliminaryDate.addTimeInterval(fraction)

            }

        }

        return preliminaryDate

    }

}

In my case I have to convert the DynamoDB - lastUpdated column (Unix Timestamp) to Normal Time.

The initial value of lastUpdated was : 1460650607601 - converted down to 2016-04-14 16:16:47 +0000 via :

   if let lastUpdated : String = userObject.lastUpdated {



                let epocTime = NSTimeInterval(lastUpdated)! / 1000 // convert it from milliseconds dividing it by 1000



                let unixTimestamp = NSDate(timeIntervalSince1970: epocTime) //convert unix timestamp to Date

                let dateFormatter = NSDateFormatter()

                dateFormatter.timeZone = NSTimeZone()

                dateFormatter.locale = NSLocale.currentLocale() // NSLocale(localeIdentifier: "en_US_POSIX")

                dateFormatter.dateFormat =  "yyyy-MM-dd'T'HH:mm:ssZZZZZ"

                dateFormatter.dateFromString(String(unixTimestamp))



                let updatedTimeStamp = unixTimestamp

                print(updatedTimeStamp)



            }

In the future the format might need to be changed which could be a small head ache having date.dateFromISO8601 calls everywhere in an app. Use a class and protocol to wrap the implementation, changing the date time format call in one place will be simpler. Use RFC3339 if possible, its a more complete representation. DateFormatProtocol and DateFormat is great for dependency injection.

class AppDelegate: UIResponder, UIApplicationDelegate {



    internal static let rfc3339DateFormat = "yyyy-MM-dd'T'HH:mm:ssZZZZZ"

    internal static let localeEnUsPosix = "en_US_POSIX"

}



import Foundation



protocol DateFormatProtocol {



    func format(date: NSDate) -> String

    func parse(date: String) -> NSDate?



}





import Foundation



class DateFormat:  DateFormatProtocol {



    func format(date: NSDate) -> String {

        return date.rfc3339

    }



    func parse(date: String) -> NSDate? {

        return date.rfc3339

    }



}





extension NSDate {



    struct Formatter {

        static let rfc3339: NSDateFormatter = {

            let formatter = NSDateFormatter()

            formatter.calendar = NSCalendar(calendarIdentifier: NSCalendarIdentifierISO8601)

            formatter.locale = NSLocale(localeIdentifier: AppDelegate.localeEnUsPosix)

            formatter.timeZone = NSTimeZone(forSecondsFromGMT: 0)

            formatter.dateFormat = rfc3339DateFormat

            return formatter

        }()

    }



    var rfc3339: String { return Formatter.rfc3339.stringFromDate(self) }

}



extension String {

    var rfc3339: NSDate? {

        return NSDate.Formatter.rfc3339.dateFromString(self)

    }

}







class DependencyService: DependencyServiceProtocol {



    private var dateFormat: DateFormatProtocol?



    func setDateFormat(dateFormat: DateFormatProtocol) {

        self.dateFormat = dateFormat

    }



    func getDateFormat() -> DateFormatProtocol {

        if let dateFormatObject = dateFormat {



            return dateFormatObject

        } else {

            let dateFormatObject = DateFormat()

            dateFormat = dateFormatObject



            return dateFormatObject

        }

    }



}

There is a new ISO8601DateFormatter class that let's you create a string with just one line. For backwards compatibility I used an old C-library. I hope this is useful for someone.

Swift 3.0

extension Date {

    var iso8601: String {

        if #available(OSX 10.12, iOS 10.0, watchOS 3.0, tvOS 10.0, *) {

            return ISO8601DateFormatter.string(from: self, timeZone: TimeZone.current, formatOptions: .withInternetDateTime)

        } else {

            var buffer = [CChar](repeating: 0, count: 25)

            var time = time_t(self.timeIntervalSince1970)

            strftime_l(&buffer, buffer.count, "%FT%T%z", localtime(&time), nil)

            return String(cString: buffer)

        }

    }

}

Uses ISO8601DateFormatter on iOS10 or newer.

Uses DateFormatter on iOS9 or older.

Swift 4

protocol DateFormatterProtocol {

    func string(from date: Date) -> String

    func date(from string: String) -> Date?

}



extension DateFormatter: DateFormatterProtocol {}



@available(iOS 10.0, *)

extension ISO8601DateFormatter: DateFormatterProtocol {}



struct DateFormatterShared {

    static let iso8601: DateFormatterProtocol = {

        if #available(iOS 10, *) {

            return ISO8601DateFormatter()

        } else {

            // iOS 9

            let formatter = DateFormatter()

            formatter.calendar = Calendar(identifier: .iso8601)

            formatter.locale = Locale(identifier: "en_US_POSIX")

            formatter.timeZone = TimeZone(secondsFromGMT: 0)

            formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX"

            return formatter

        }

    }()

}

To complement the version of Leo Dabus, I added support for projects written Swift and Objective-C, also added support for the optional milliseconds, probably isn't the best but you would get the point:

Xcode 8 and Swift 3

extension Date {

    struct Formatter {

        static let iso8601: DateFormatter = {

            let formatter = DateFormatter()

            formatter.calendar = Calendar(identifier: .iso8601)

            formatter.locale = Locale(identifier: "en_US_POSIX")

            formatter.timeZone = TimeZone(secondsFromGMT: 0)

            formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSXXXXX"

            return formatter

        }()

    }



    var iso8601: String {

        return Formatter.iso8601.string(from: self)

    }

}





extension String {

    var dateFromISO8601: Date? {

        var data = self

        if self.range(of: ".") == nil {

            // Case where the string doesn't contain the optional milliseconds

            data = data.replacingOccurrences(of: "Z", with: ".000000Z")

        }

        return Date.Formatter.iso8601.date(from: data)

    }

}





extension NSString {

    var dateFromISO8601: Date? {

        return (self as String).dateFromISO8601

    }

}

Without some manual String masks or TimeFormatters

import Foundation



struct DateISO: Codable {

    var date: Date

}



extension Date{

    var isoString: String {

        let encoder = JSONEncoder()

        encoder.dateEncodingStrategy = .iso8601

        guard let data = try? encoder.encode(DateISO(date: self)),

        let json = try? JSONSerialization.jsonObject(with: data, options: .allowFragments) as?  [String: String]

            else { return "" }

        return json?.first?.value ?? ""

    }

}



let dateString = Date().isoString