Date es Comparable & Equatable (a partir de Swift 3)

Esta respuesta complementa la respuesta de @Ankit Thakur.

Desde Swift 3 la estructura Date (basada en la clase NSDate subyacente) adopta la Comparable y Equatable protocolos.

• Comparable requiere que Date implementar los operadores: <, <=, >, >=.
• Equatable requiere que Date implemente el operador ==.
• Equatable permite a Date utilizar la implementación predeterminada de el operador != (que es el inverso de la Equatable == operator implementation).

El siguiente código de ejemplo ejerce estos operadores de comparación y confirma qué comparaciones son verdaderas con las sentencias print.

Función de comparación

import Foundation

func describeComparison(date1: Date, date2: Date) -> String {

    var descriptionArray: [String] = []

    if date1 < date2 {
        descriptionArray.append("date1 < date2")
    }

    if date1 <= date2 {
        descriptionArray.append("date1 <= date2")
    }

    if date1 > date2 {
        descriptionArray.append("date1 > date2")
    }

    if date1 >= date2 {
        descriptionArray.append("date1 >= date2")
    }

    if date1 == date2 {
        descriptionArray.append("date1 == date2")
    }

    if date1 != date2 {
        descriptionArray.append("date1 != date2")
    }

    return descriptionArray.joined(separator: ",  ")
}

Uso de la muestra

let now = Date()

describeComparison(date1: now, date2: now.addingTimeInterval(1))
// date1 < date2,  date1 <= date2,  date1 != date2

describeComparison(date1: now, date2: now.addingTimeInterval(-1))
// date1 > date2,  date1 >= date2,  date1 != date2

describeComparison(date1: now, date2: now)
// date1 <= date2,  date1 >= date2,  date1 == date2

En Swift 3, La fecha es Comparable por lo que podemos comparar directamente fechas como

let date1 = Date()
let date2 = Date()

let isGreater = date1 > date2
print(isGreater)

let isSmaller = date1 < date2
print(isSmaller)

let isEqual = date1 == date2
print(isEqual)

Mira esto http://iswift.org/cookbook/compare-2-dates

Obtener fechas:

// Get current date
let dateA = NSDate()

// Get a later date (after a couple of milliseconds)
let dateB = NSDate()

Usando la instrucción SWITCH

// Compare them
switch dateA.compare(dateB) {
    case .OrderedAscending     :   print("Date A is earlier than date B")
    case .OrderedDescending    :   print("Date A is later than date B")
    case .OrderedSame          :   print("The two dates are the same")
}

Usando la Instrucción IF

 if datePickerTo.date.compare(datePicker.date) == .orderedAscending {
     datePickerTo.date = datePicker.date
 }

Para mí el problema era que tenía mi propia clase extension to Date que definía todos los operadores de comparación. Ahora (ya que swift 3) esa fecha es comparable, estas extensiones no son necesarias. Así que los comenté y funcionó.

SWIFT 3: No sé si esto es lo que estás buscando. Pero comparo una cadena con una marca de tiempo actual para ver si mi cadena es más antigua que ahora.

func checkTimeStamp(date: String!) -> Bool {
        let dateFormatter: DateFormatter = DateFormatter()
        dateFormatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
        dateFormatter.locale = Locale(identifier:"en_US_POSIX")
        let datecomponents = dateFormatter.date(from: date)

        let now = Date()

        if (datecomponents! >= now) {
            return true
        } else {
            return false
        }
    }

Para usarlo:

if (checkTimeStamp(date:"2016-11-21 12:00:00") == false) {
    // Do something
}

Para comparar la fecha solo con el año-mes-día y sin tiempo para mí funcionó así:

     let order = Calendar.current.compare(self.startDate, to: compareDate!, toGranularity: .day)  

                      switch order {
                        case .orderedAscending:
                            print("\(gpsDate) is after \(self.startDate)")
                        case .orderedDescending:
                            print("\(gpsDate) is before \(self.startDate)")
                        default:
                            print("\(gpsDate) is the same as \(self.startDate)")
                        }

En el momento de escribir este artículo, Swift admite de forma nativa la comparación de Fechas con todos los operadores de comparación (i. e.<, <=, ==, >=, y >). También puede comparar fechas opcionales, pero están limitadas a <, ==, y >. Si necesita comparar dos fechas opcionales usando <= o >=, es decir,

let date1: Date? = ...
let date2: Date? = ...
if date1 >= date2 { ... }

Puede sobrecargar los operadores <= y >=para soportar opcionales:

func <= <T: Comparable>(lhs: T?, rhs: T?) -> Bool {
    return lhs == rhs || lhs < rhs
}

func >= <T: Comparable>(lhs: T?, rhs: T?) -> Bool {
    return lhs == rhs || lhs > rhs
}

extension Date {
 func isBetween(_ date1: Date, and date2: Date) -> Bool {
    return (min(date1, date2) ... max(date1, date2)).contains(self)
  }
}

let resultArray = dateArray.filter { $0.dateObj!.isBetween(startDate, and: endDate) }

Otra forma de hacerlo:

    switch date1.compare(date2) {
        case .orderedAscending:
            break

        case .orderedDescending:
            break;

        case .orderedSame:
            break
    }