Comparação NSDate usando Swift

153

Estou trabalhando em um aplicativo que exige a verificação da data de vencimento para a lição de casa. Quero saber se uma data de vencimento está dentro da próxima semana e se é uma ação.
A maior parte da documentação que encontrei está no Objective-C e não consigo descobrir como fazê-lo no Swift. Obrigado pela ajuda!!

Henry oscannlain-miller
fonte
2
rápida não tem uma classe data em que você usar o Objective classe C NSDate - assim você ter encontrado a documentação correta
mmmmmm
Possível duplicação de Comparando NSDates sem componente de tempo . Existem muitas respostas muito boas.
JWW
Resposta relacionada: stackoverflow.com/questions/29652771/…
jkdev 9/16
2
Swift 3 tem uma Dateclasse. É ligado NSDate, mas é chamado Date.
BallpointBen

Respostas:

188

Eu gosto de usar extensões para tornar o código mais legível. Aqui estão algumas extensões do NSDate que podem ajudar a limpar seu código e facilitar o entendimento. Coloquei isso em um arquivo sharedCode.swift:

extension NSDate {

    func isGreaterThanDate(dateToCompare: NSDate) -> Bool {
        //Declare Variables
        var isGreater = false

        //Compare Values
        if self.compare(dateToCompare as Date) == ComparisonResult.orderedDescending {
            isGreater = true
        }

        //Return Result
        return isGreater
    }

    func isLessThanDate(dateToCompare: NSDate) -> Bool {
        //Declare Variables
        var isLess = false

        //Compare Values
        if self.compare(dateToCompare as Date) == ComparisonResult.orderedAscending {
            isLess = true
        }

        //Return Result
        return isLess
    }

    func equalToDate(dateToCompare: NSDate) -> Bool {
        //Declare Variables
        var isEqualTo = false

        //Compare Values
        if self.compare(dateToCompare as Date) == ComparisonResult.orderedSame {
            isEqualTo = true
        }

        //Return Result
        return isEqualTo
    }

    func addDays(daysToAdd: Int) -> NSDate {
        let secondsInDays: TimeInterval = Double(daysToAdd) * 60 * 60 * 24
        let dateWithDaysAdded: NSDate = self.addingTimeInterval(secondsInDays)

        //Return Result
        return dateWithDaysAdded
    }

    func addHours(hoursToAdd: Int) -> NSDate {
        let secondsInHours: TimeInterval = Double(hoursToAdd) * 60 * 60
        let dateWithHoursAdded: NSDate = self.addingTimeInterval(secondsInHours)

        //Return Result
        return dateWithHoursAdded
    }
}

Agora, se você pode fazer algo assim:

//Get Current Date/Time
var currentDateTime = NSDate()

//Get Reminder Date (which is Due date minus 7 days lets say)
var reminderDate = dueDate.addDays(-7)

//Check if reminderDate is Greater than Right now
if(reminderDate.isGreaterThanDate(currentDateTime)) {
    //Do Something...
}
user2266987
fonte
28
Você deve simplificar seu código. return self.compare(dateToCompare) == NSComparisonResult.OrderedDescending
amigos estão dizendo sobre olav gausaker
5
O isEqualToDate também é fornecido pela Apple. Sua declaração está em conflito com a definida pela Apple.
Shamas S - Restabelecer Monica
4
Não é todo dia tem 24 horas
Leo Dabus
9
Esta resposta é terrível e nunca deve ser a aceita. Não sempre adicionar intervalos de tempo para datas que são criadas por você. É exatamente por isso que NSDateComponentsexiste. Há uma série de casos de borda que não estão sendo pega corretamente e não faz sentido para não adicionar a conformidade com Comparablea NSDate. Eu recomendo usar a solução de John .
fpg1503
3
Uma solução melhor é fazer NSDate Equatable, comparáveis, em seguida, você poderia simplesmente fazerdate1 < date2
aryaxt
209

Se você quiser apoiar ==, <, >, <=, ou >=para NSDates, você só tem que declarar isso em algum lugar:

public func ==(lhs: NSDate, rhs: NSDate) -> Bool {
    return lhs === rhs || lhs.compare(rhs) == .OrderedSame
}

public func <(lhs: NSDate, rhs: NSDate) -> Bool {
    return lhs.compare(rhs) == .OrderedAscending
}

extension NSDate: Comparable { }
John Estropia
fonte
2
O @Isuru Comparableé um descendente do Equatableprotocolo, portanto você não precisa declarar conformidade com ambos.
John Estropia
2
Apenas curioso por que não é construído por padrão ?!
dVaffection
3
@dVaffection Em Objective-C (onde NSDate e amigos são declarados), se você comparar com ==, <, >, etc., você estará recebendo um resultado da comparação de seu endereço na memória, e não a comparação do seu valor real. No Swift, eles ainda são tratados como referências, então acho que a escolha foi (1) manter comparações por ponteiro como no ObjC, ou (2) eliminar a confusão por não fornecer uma implementação para comparações.
John Estropia
2
Um benefício adicional dessa abordagem é que Array.maxElement()etc está automaticamente disponível de matrizes de NSDates.
pr1001
1
@MarcioCruz É apenas um requisito rápido que todas as implementações de operadores estejam no escopo global. Veja a discussão aqui: stackoverflow.com/questions/35246003/…
John Estropia
54

É assim que você compara dois NSDates no Swift, que acabei de testar no playground do Xcode:

if date1.compare(date2) == NSComparisonResult.OrderedDescending
{
    NSLog("date1 after date2");
} else if date1.compare(date2) == NSComparisonResult.OrderedAscending
{
    NSLog("date1 before date2");
} else
{
    NSLog("dates are equal");
}

Portanto, para verificar se há uma data dueDatedentro de uma semana:

let dueDate=...

let calendar = NSCalendar.currentCalendar()
let comps = NSDateComponents()
comps.day = 7
let date2 = calendar.dateByAddingComponents(comps, toDate: NSDate(), options: NSCalendarOptions.allZeros)

if dueDate.compare(date2!) == NSComparisonResult.OrderedDescending
{
    NSLog("not due within a week");
} else if dueDate.compare(date2!) == NSComparisonResult.OrderedAscending
{
    NSLog("due within a week");
} else
{
    NSLog("due in exactly a week (to the second, this will rarely happen in practice)");
}
Desfazer
fonte
2
descendente ordenado significa que data1> data2?
Henry oscannlain-miller
1
Sim, @ Henryoscannlain-miller.
Desfazer
46

Eu sempre fiz isso em uma linha:

let greater = date1.timeIntervalSince1970 < date2.timeIntervalSince1970

Ainda legível no ifbloco

ReDetecção
fonte
12

No Swift3, a Dateestrutura no Foundationagora implementa o Comparableprotocolo. Portanto, as NSDateabordagens anteriores do Swift2 são substituídas pelo Swift3 Date.

/**
 `Date` represents a single point in time.

 A `Date` is independent of a particular calendar or time zone. To represent a `Date` to a user, you must interpret it in the context of a `Calendar`.
*/
public struct Date : ReferenceConvertible, Comparable, Equatable {

    // .... more         

    /**
        Returns the interval between the receiver and another given date.

        - Parameter another: The date with which to compare the receiver.

        - Returns: The interval between the receiver and the `another` parameter. If the receiver is earlier than `anotherDate`, the return value is negative. If `anotherDate` is `nil`, the results are undefined.

        - SeeAlso: `timeIntervalSince1970`
        - SeeAlso: `timeIntervalSinceNow`
        - SeeAlso: `timeIntervalSinceReferenceDate`
        */
    public func timeIntervalSince(_ date: Date) -> TimeInterval

   // .... more 

    /// Returns true if the two `Date` values represent the same point in time.
    public static func ==(lhs: Date, rhs: Date) -> Bool

    /// Returns true if the left hand `Date` is earlier in time than the right hand `Date`.
    public static func <(lhs: Date, rhs: Date) -> Bool

    /// Returns true if the left hand `Date` is later in time than the right hand `Date`.
    public static func >(lhs: Date, rhs: Date) -> Bool

    /// Returns a `Date` with a specified amount of time added to it.
    public static func +(lhs: Date, rhs: TimeInterval) -> Date

    /// Returns a `Date` with a specified amount of time subtracted from it.
    public static func -(lhs: Date, rhs: TimeInterval) -> Date

  // .... more
}

Nota ...

No Swift3, Dateé struct, significa que é value type. NSDateé classsim reference type.

// Swift3
let a = Date()
let b = a //< `b` will copy `a`. 

// So, the addresses between `a` and `b` are different.
// `Date` is some kind different with `NSDate`.
AechoLiu
fonte
6
extension NSDate {

    // MARK: - Dates comparison

    func isGreaterThanDate(dateToCompare: NSDate) -> Bool {

        return self.compare(dateToCompare) == NSComparisonResult.OrderedDescending
    }

    func isLessThanDate(dateToCompare: NSDate) -> Bool {

        return self.compare(dateToCompare) == NSComparisonResult.OrderedAscending
    }

    func equalToDate(dateToCompare: NSDate) -> Bool {

        return self.compare(dateToCompare) == NSComparisonResult.OrderedSame
    }
}
Yura Voevodin
fonte
6

Se você deseja comparar datas com granularidade (apenas no mesmo dia ou ano, etc.) no 3 rápido.

func compareDate(date1:NSDate, date2:NSDate, toUnitGranularity: NSCalendar.Unit) -> Bool {

 let order = NSCalendar.current.compare(date1 as Date, to: date2 as Date, toGranularity: .day)
 switch order {
 case .orderedSame:
   return true
 default:
   return false
 }
}

Para outras comparações de calendário, mude .day para;

.ano. mês. dia. hora. minuto. segundo

SashaZ
fonte
5

O Swift já implementa a comparação de datas, use date1> date2 e assim por diante.

/// Returns true if the two `Date` values represent the same point in time.
public static func ==(lhs: Date, rhs: Date) -> Bool

/// Returns true if the left hand `Date` is earlier in time than the right hand `Date`.
public static func <(lhs: Date, rhs: Date) -> Bool

/// Returns true if the left hand `Date` is later in time than the right hand `Date`.
public static func >(lhs: Date, rhs: Date) -> Bool

/// Returns a `Date` with a specified amount of time added to it.
public static func +(lhs: Date, rhs: TimeInterval) -> Date

/// Returns a `Date` with a specified amount of time subtracted from it.
public static func -(lhs: Date, rhs: TimeInterval) -> Date

/// Add a `TimeInterval` to a `Date`.
///
/// - warning: This only adjusts an absolute value. If you wish to add calendrical concepts like hours, days, months then you must use a `Calendar`. That will take into account complexities like daylight saving time, months with different numbers of days, and more.
public static func +=(lhs: inout Date, rhs: TimeInterval)

/// Subtract a `TimeInterval` from a `Date`.
///
/// - warning: This only adjusts an absolute value. If you wish to add calendrical concepts like hours, days, months then you must use a `Calendar`. That will take into account complexities like daylight saving time, months with different numbers of days, and more.
public static func -=(lhs: inout Date, rhs: TimeInterval)
Trung Phan
fonte
4

no Swift 3, a data é comparável para que possamos comparar diretamente datas como

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

let isGreater = date1 > date2
print(isGreater)

let isEqual = date1 == date2
print(isEqual)

ou alternativamente

let result = date1.compare(date2)
switch result {
    case .OrderedAscending     :   print("date 1 is earlier than date 2")
    case .OrderedDescending    :   print("date 1 is later than date 2")
    case .OrderedSame          :   print("two dates are the same")
}

melhor maneira de criar extensionna Data

extension Date {

  fun isGreater(than date: Date) -> Bool {
    return self > date 
  }

  func isSmaller(than date: Date) -> Bool {
    return self < date
  }

  func isEqual(to date: Date) -> Bool {
    return self == date
  }

}

uso let isGreater = date1.isGreater(than: date2)

Suhit Patil
fonte
3

Essa função funcionou para mim para comparar se uma data (startDate) era após o endDate, em que ambas foram definidas como variáveis ​​NSDate:

if startDate.compare(endDate as Date) == ComparisonResult.orderedDescending
Diskprotek
fonte
2

implementação em Swift

let documentsPath = NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0] as NSString
let files = NSFileManager.defaultManager().contentsOfDirectoryAtPath(documentsPath, error: nil)

let filesAndProperties = NSMutableArray()
for file in files! {

    let filePath = documentsPath.stringByAppendingString(file as NSString)
    let properties = NSFileManager.defaultManager().attributesOfItemAtPath(filePath, error: nil)
    let modDate = properties![NSFileModificationDate] as NSDate
    filesAndProperties.addObject(NSDictionary(objectsAndKeys: file, "path", modDate, "lastModDate"))
}

let sortedFiles = filesAndProperties.sortedArrayUsingComparator({
    (path1, path2) -> NSComparisonResult in

    var comp = (path1.objectForKey("lastModDate") as NSDate).compare(path2.objectForKey("lastModDate") as NSDate)
    if comp == .OrderedDescending {

        comp = .OrderedAscending
    } else if comp == .OrderedAscending {

        comp = .OrderedDescending
    }

    return comp
})
János
fonte
2
var dateFormatter = NSDateFormatter()
dateFormatter.dateFormat = "yyyy-MM-dd"
let dateData: String = dateFormatter.stringFromDate(date1)
let testDate: String = dateFormatter.stringFromDate(date2)
print(dateData == testDate)
Trevor Jordet
fonte
1
someArray.sort({($0.dateAdded?.timeIntervalSinceReferenceDate)! < ($1.dateAdded?.timeIntervalSinceReferenceDate)!})

dateAdded é uma variável NSDate no meu objeto

class MyClass {
    let dateAdded: NSDate?
}
larod
fonte
1

Temos um cenário para verificar se as horas atuais estão em preto e branco duas vezes (duas datas). Por exemplo, quero verificar a mentira atual entre o horário de abertura da clínica (Hospital) e o horário de fechamento.

Use o código simples.

      NSDate * now = [NSDate date];
        NSDateFormatter *outputFormatter = [[NSDateFormatter alloc] init];
        [outputFormatter setDateFormat:@"HH:mm:ss"];

        //current time
        NSString *currentTimeString = [outputFormatter stringFromDate:now];
        NSDate *dateCurrent = [outputFormatter dateFromString:currentTimeString];


        NSString *timeStart = @"09:00:00";
        NSString *timeEnd = @"22:00:00";

        NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
        [formatter setDateFormat:@"HH:mm:ss"];

        NSDate *dateStart= [formatter timeStart];
        NSDate *dateEnd = [formatter timeEnd];
        NSComparisonResult result = [dateCurrent compare:dateStart];
        NSComparisonResult resultSecond = [date2 compare:dateEnd];

if(result == NSOrderedDescending && resultSecond == NSOrderedDescending)
        {
            NSLog(@"current time lies in starting and end time");
    }else {
            NSLog(@"current time doesn't lie in starting and end time");
        }
Maninderjit Singh
fonte
1

Para o Swift 3, você pode usar a função abaixo para comparar entre duas datas.

func compareDate(dateInitial:Date, dateFinal:Date) -> Bool {
    let order = Calendar.current.compare(dateInitial, to: dateFinal, toGranularity: .day)
    switch order {
    case .orderedSame:
        return true
    default:
        return false
    }
}

toGranularity pode ser alterado de acordo com as restrições nas quais você deseja aplicar sua comparação.

Himanshu
fonte
1

Para estender o SashaZ

Swift iOS 8 ou superior Quando você precisa de mais do que simplesmente comparações de datas maiores ou menores. Por exemplo, é o mesmo dia ou o dia anterior, ...

Nota: nunca esqueça o fuso horário. O fuso horário da agenda tem um padrão, mas se você não gostar do padrão, precisará definir o fuso horário. Para saber em que dia é, você precisa saber em qual fuso horário está perguntando.

extension Date {
    func compareTo(date: Date, toGranularity: Calendar.Component ) -> ComparisonResult  {
        var cal = Calendar.current
        cal.timeZone = TimeZone(identifier: "Europe/Paris")!
        return cal.compare(self, to: date, toGranularity: toGranularity)
        }
    }

Use-o assim:

if thisDate.compareTo(date: Date(), toGranularity: .day) == .orderedDescending {
// thisDate is a previous day
}

De um exemplo mais complexo. Localize e filtre todas as datas em uma matriz, que são do mesmo dia que "findThisDay":

let formatter = DateFormatter()
formatter.timeZone = TimeZone(identifier: "Europe/Paris")
formatter.dateFormat = "yyyy/MM/dd HH:mm:ss"

let findThisDay = formatter.date(from: "2018/11/05 08:11:08")!
_ = [
    formatter.date(from: "2018/12/05 08:08:08")!, 
    formatter.date(from: "2018/11/05 08:11:08")!,
    formatter.date(from: "2018/11/05 11:08:22")!,
    formatter.date(from: "2018/11/05 22:08:22")!,
    formatter.date(from: "2018/11/05 08:08:22")!,
    formatter.date(from: "2018/11/07 08:08:22")!,
    ]
    .filter{ findThisDay.compareTo(date: $0 , toGranularity: .day) == .orderedSame }
    .map { print(formatter.string(from: $0)) }
t1ser
fonte