try - what does it mean iphone is disabled

Round NSDate a los 5 minutos más cercanos

Question

Por ejemplo, tengo

NSDate *curDate = [NSDate date];

y su valor es 9:13 a.m. No estoy usando partes de año, mes y día de curDate.

Lo que quiero obtener es una fecha con un valor de tiempo de 9:15; Si tengo un valor de tiempo de 9:16 quiero avanzar a 9:20 y así sucesivamente.

¿Cómo puedo hacer eso con NSDate?

Answer 1

¿Qué tal esto basado en Chris ''y swift3

import UIKit

enum DateRoundingType {
    case round
    case ceil
    case floor
}

extension Date {
    func rounded(minutes: TimeInterval, rounding: DateRoundingType = .round) -> Date {
        return rounded(seconds: minutes * 60, rounding: rounding)
    }
    func rounded(seconds: TimeInterval, rounding: DateRoundingType = .round) -> Date {
        var roundedInterval: TimeInterval = 0
        switch rounding  {
        case .round:
            roundedInterval = (timeIntervalSinceReferenceDate / seconds).rounded() * seconds
        case .ceil:
            roundedInterval = ceil(timeIntervalSinceReferenceDate / seconds) * seconds
        case .floor:
            roundedInterval = floor(timeIntervalSinceReferenceDate / seconds) * seconds
        }
        return Date(timeIntervalSinceReferenceDate: roundedInterval)
    }
}

// Example

let nextFiveMinuteIntervalDate = Date().rounded(minutes: 5, rounding: .ceil)
print(nextFiveMinuteIntervalDate)

Answer 2

Aquí está mi solución al problema original (redondeando) usando la idea del envoltorio de ayianni.

-(NSDate *)roundDateToCeiling5Minutes:(NSDate *)mydate{
    // Get the nearest 5 minute block
    NSDateComponents *time = [[NSCalendar currentCalendar]
                                           components:NSHourCalendarUnit | NSMinuteCalendarUnit
                                             fromDate:mydate];
    NSInteger minutes = [time minute];
    int remain = minutes % 5;
    // Add the remainder of time to the date to round it up evenly
    mydate = [mydate addTimeInterval:60*(5-remain)];
    return mydate;
}

Answer 3

Aquí está mi solución:

NSTimeInterval seconds = round([date timeIntervalSinceReferenceDate]/300.0)*300.0;
NSDate *rounded = [NSDate dateWithTimeIntervalSinceReferenceDate:seconds];

Hice algunas pruebas y es aproximadamente diez veces más rápido que la solución de Voss. Con iteraciones de 1M tomó aproximadamente 3,39 segundos. Este se realizó en 0.38 segundos. La solución de J3RM tomó 0.50 segundos. El uso de la memoria también debería ser el más bajo.

No es que el rendimiento lo sea todo, pero es de una sola línea. También puede controlar fácilmente el redondeo con división y multiplicación.

EDITAR: para responder a la pregunta, puede usar ceil para redondear correctamente:

NSTimeInterval seconds = ceil([date timeIntervalSinceReferenceDate]/300.0)*300.0;
NSDate *rounded = [NSDate dateWithTimeIntervalSinceReferenceDate:seconds];

EDITAR: Una extensión en Swift:

public extension Date {

    public func round(precision: TimeInterval) -> Date {
        return round(precision: precision, rule: .toNearestOrAwayFromZero)
    }

    public func ceil(precision: TimeInterval) -> Date {
        return round(precision: precision, rule: .up)
    }

    public func floor(precision: TimeInterval) -> Date {
        return round(precision: precision, rule: .down)
    }

    private func round(precision: TimeInterval, rule: FloatingPointRoundingRule) -> Date {
        let seconds = (self.timeIntervalSinceReferenceDate / precision).rounded(rule) *  precision;
        return Date(timeIntervalSinceReferenceDate: seconds)
    }
}

Answer 4

Creo que esta es la mejor solución, pero solo mi opinión, basada en el código de poster anterior. redondea a la marca de 5 minutos más cercana. Este código debería usar mucha menos memoria que las soluciones de componentes de fecha. Brillante, gracias por la dirección.

+(NSDate *) dateRoundedDownTo5Minutes:(NSDate *)dt{
    int referenceTimeInterval = (int)[dt timeIntervalSinceReferenceDate];
    int remainingSeconds = referenceTimeInterval % 300;
    int timeRoundedTo5Minutes = referenceTimeInterval - remainingSeconds; 
    if(remainingSeconds>150)
    {/// round up
         timeRoundedTo5Minutes = referenceTimeInterval +(300-remainingSeconds);            
    }
    NSDate *roundedDate = [NSDate dateWithTimeIntervalSinceReferenceDate:(NSTimeInterval)timeRoundedTo5Minutes];
    return roundedDate;
}

Answer 5

Empecé a experimentar con esto para una aplicación mía, y se me ocurrió lo siguiente. Está en Swift, pero el concepto debería ser lo suficientemente comprensible, incluso si no conoce Swift.

func skipToNextEvenFiveMinutesFromDate(date: NSDate) -> NSDate {
   var componentMask : NSCalendarUnit = (NSCalendarUnit.CalendarUnitYear | NSCalendarUnit.CalendarUnitMonth | NSCalendarUnit.CalendarUnitDay | NSCalendarUnit.CalendarUnitHour | NSCalendarUnit.CalendarUnitMinute)
   var components = NSCalendar.currentCalendar().components(componentMask, fromDate: date)

   components.minute += 5 - components.minute % 5
   components.second = 0
   if (components.minute == 0) {
      components.hour += 1
   }

   return NSCalendar.currentCalendar().dateFromComponents(components)!
}

El resultado se ve correcto en mi patio de recreo, donde inyecté varias fechas personalizadas, cerca de la medianoche, cerca de un nuevo año, etc.

Editar: compatibilidad con Swift2:

 func skipToNextEvenFiveMinutesFromDate(date: NSDate) -> NSDate {
    let componentMask : NSCalendarUnit = ([NSCalendarUnit.Year , NSCalendarUnit.Month , NSCalendarUnit.Day , NSCalendarUnit.Hour ,NSCalendarUnit.Minute])
    let components = NSCalendar.currentCalendar().components(componentMask, fromDate: date)

    components.minute += 5 - components.minute % 5
    components.second = 0
    if (components.minute == 0) {
        components.hour += 1
    }

    return NSCalendar.currentCalendar().dateFromComponents(components)!
}

Answer 6

Esta es una solución genérica que redondea a la entrada más cercana ''minutos'':

+(NSDate *)roundUpDate:(NSDate *)aDate toNearestMins:(NSInteger)mins
{
    NSDateComponents *components = [[NSCalendar currentCalendar] components:NSUIntegerMax fromDate:aDate];

    NSInteger dateMins = components.minute;
    dateMins = ((dateMins+mins)/mins)*mins;

    [components setMinute:dateMins];
    [components setSecond:0];
    return [[NSCalendar currentCalendar] dateFromComponents:components];
}

Answer 7

Gracias por la muestra. Debajo he agregado un código de la ronda a los 5 minutos más cercanos

 -(NSDate *)roundDateTo5Minutes:(NSDate *)mydate{
    // Get the nearest 5 minute block
    NSDateComponents *time = [[NSCalendar currentCalendar]
                              components:NSHourCalendarUnit | NSMinuteCalendarUnit
                              fromDate:mydate];
    NSInteger minutes = [time minute];
    int remain = minutes % 5;
    // if less then 3 then round down
    if (remain<3){
        // Subtract the remainder of time to the date to round it down evenly
        mydate = [mydate addTimeInterval:-60*(remain)];
    }else{
        // Add the remainder of time to the date to round it up evenly
        mydate = [mydate addTimeInterval:60*(5-remain)];
    }
    return mydate;
}

Answer 8

Había estado buscando esto por mí mismo, pero usando el ejemplo anterior me dio fechas del año 0001.

Aquí está mi alternativa, incorporada con la sugerencia de mod más elegante de smorgan, aunque ten cuidado, no he probado esto aún:

NSDate *myDate = [NSDate date];
// Get the nearest 5 minute block
NSDateComponents *time = [[NSCalendar currentCalendar] components:NSHourCalendarUnit | NSMinuteCalendarUnit
                                                         fromDate:myDate];
NSInteger minutes = [time minute];
int remain = minutes % 5;
// Add the remainder of time to the date to round it up evenly
myDate = [myDate addTimeInterval:60*(5-remain)];

Answer 9

Incluso más corto ... límite a segundos:

let seconds = ceil(Date().timeIntervalSinceReferenceDate/300.0)*300.0
let roundedDate = Date(timeIntervalSinceReferenceDate: seconds)

Answer 10

Lamentablemente, la mayoría de las respuestas no son perfectamente correctas (aunque parecen funcionar bastante bien para la mayoría de los usuarios), ya que o bien confían en el calendario del sistema activo actual como en un calendario gregoriano (que puede no ser el caso) o en el hecho los segundos intercalares no existen y / o siempre serán ignorados por OS X un iOS. El siguiente código funciona copiar y pegar, se garantiza que es correcto y no hace tales suposiciones (y tampoco se romperá en el futuro si Apple cambia el soporte de segundos intercalados, ya que en ese caso NSCalendar también deberá soportarlos correctamente):

{
    NSDate * date;
    NSUInteger units;
    NSCalendar * cal;
    NSInteger minutes;
    NSDateComponents * comp;

    // Get current date
    date = [NSDate date];

    // Don''t rely that `currentCalendar` is a
    // Gregorian calendar that works the way we are used to.
    cal = [[NSCalendar alloc]
        initWithCalendarIdentifier:NSGregorianCalendar
    ];
    [cal autorelease]; // Delete that line if using ARC

    // Units for the day
    units = NSYearCalendarUnit | NSMonthCalendarUnit | NSDayCalendarUnit;
    // Units for the time (seconds are irrelevant)
    units |= NSHourCalendarUnit | NSMinuteCalendarUnit;

    // Split current date into components
    comp = [cal components:units fromDate:date];

    // Get the minutes,
    // will be a number between 0 and 59.
    minutes = [comp minute];
    // Unless it is a multiple of 5...
    if (minutes % 5) {
        // ... round up to the nearest multiple of 5.
        minutes = ((minutes / 5) + 1) * 5;
    }

    // Set minutes again.
    // Minutes may now be a value between 0 and 60,
    // but don''t worry, NSCalendar knows how to treat overflows!
    [comp setMinute:minutes];

    // Convert back to date
    date = [cal dateFromComponents:comp];
}

Si la hora actual ya es un múltiplo de 5 minutos, el código no lo cambiará. La pregunta original no especificó este caso explícitamente. Si el código siempre se redondeará al próximo múltiplo de 5 minutos, simplemente elimine la prueba if (minutes % 5) { y siempre redondeará.

Answer 11

No estoy seguro de cuán eficientes son los NSDateComponents, pero si solo quieres tratar con el NSDate mismo, puede darte valores basados ​​en segundos que luego pueden ser manipulados.

Por ejemplo, este método redondea al minuto más cercano. Cambia los 60 a 300 y redondeará a los próximos 5 minutos.

+ (NSDate *)dateRoundedDownToMinutes:(NSDate *)date {
    // Strip miliseconds by converting to int
    int referenceTimeInterval = (int)[date timeIntervalSinceReferenceDate];

    int remainingSeconds = referenceTimeInterval % 60;
    int timeRoundedDownToMinutes = referenceTimeInterval - remainingSeconds;

    NSDate *roundedDownDate = [NSDate dateWithTimeIntervalSinceReferenceDate:(NSTimeInterval)timeRoundedDownToMinutes];

    return roundedDownDate;
}

Answer 12

Reescribí la solución de @ J3RM como una extensión en Swift en la clase NSDate. Aquí está para redondear una fecha al intervalo de 15 minutos más cercano:

extension NSDate
{
    func nearestFifteenthMinute() -> NSDate!
    {
        let referenceTimeInterval = Int(self.timeIntervalSinceReferenceDate)
        let remainingSeconds = referenceTimeInterval % 900
        var timeRoundedTo5Minutes = referenceTimeInterval - remainingSeconds
        if remainingSeconds > 450
        {
            timeRoundedTo5Minutes = referenceTimeInterval + (900 - remainingSeconds)
        }
        let roundedDate = NSDate.dateWithTimeIntervalSinceReferenceDate(NSTimeInterval(timeRoundedTo5Minutes))
        return roundedDate
    }
}

Answer 13

Sé que este es un hilo más antiguo, pero dado que hay respuestas más recientes, compartiré el método de utilidad que utilizo para redondear un NSDate al intervalo de 5 minutos más cercano.

Lo uso para llenar un UITextField con la fecha actual de UIDatePicker cuando se convierte en FirstResponder. No puede usar [NSDate date] cuando UIDatePicker está configurado con algo que no sea un intervalo de 1 minuto. Los míos están configurados con intervalos de 5 minutos.

+ (NSDate *)roundToNearest5MinuteInterval {

    NSDate *ceilingDate = [NSDate dateWithTimeIntervalSinceReferenceDate:ceil([[NSDate date] timeIntervalSinceReferenceDate]/300.0)*300.0];
    NSDate *floorDate = [NSDate dateWithTimeIntervalSinceReferenceDate:floor([[NSDate date] timeIntervalSinceReferenceDate]/300.0)*300.0];
    NSTimeInterval ceilingInterval = [ceilingDate timeIntervalSinceNow];
    NSTimeInterval floorInterval = [floorDate timeIntervalSinceNow];

    if (fabs(ceilingInterval) < fabs(floorInterval)) {
        return ceilingDate;
    } else {
        return floorDate;
    }
}

Ignorando el título de la pregunta y leyendo lo que @aler realmente quiere lograr (redondeando hacia ARRIBA a los 5 minutos más cercanos). Todo lo que tienes que hacer es lo siguiente:

NSDate *ceilingDate = [NSDate dateWithTimeIntervalSinceReferenceDate:ceil([[NSDate date] timeIntervalSinceReferenceDate]/300.0)*300.0];

Answer 14

Tome el valor de los minutos, divida por 5 redondeando para obtener la siguiente unidad de 5 minutos más alta, multiplíquelo por 5 para recuperarlo en minutos y construya un nuevo NSDate.

NSDateComponents *time = [[NSCalendar currentCalendar]
                          components:NSHourCalendarUnit | NSMinuteCalendarUnit
                            fromDate:curDate];
NSInteger minutes = [time minute];
float minuteUnit = ceil((float) minutes / 5.0);
minutes = minuteUnit * 5.0;
[time setMinute: minutes];
curDate = [[NSCalendar currentCalendar] dateFromComponents:time];

Answer 15

Una solución genérica Swift más, que funciona hasta el redondeo de 30 minutos con NSCalendar

extension NSDate {
    func nearest(minutes: Int) -> NSDate {
        assert(minutes <= 30, "nearest(m) suppport rounding up to 30 minutes");
        let cal = NSCalendar.currentCalendar();
        var time = cal.components(.CalendarUnitMinute | .CalendarUnitSecond, fromDate: self);
        let rem = time.minute % minutes
        if rem > 0 {
            time.minute = minutes - rem;
        }
        time.second = -time.second;
        time.nanosecond = -time.nanosecond //updated 7.07.15
        let date = cal.dateByAddingComponents(time, toDate: self, options: NSCalendarOptions(0));
        return date!;
    }
}

Answer 16

Wowsers, veo muchas respuestas aquí, pero muchas son largas o difíciles de entender, así que intentaré aumentar mis 2 centavos por si ayuda. La clase NSCalendar proporciona la funcionalidad necesaria, de una manera segura y concisa. Aquí hay una solución que funciona para mí, sin multiplicar segundos de intervalo de tiempo, redondeo ni nada. NSCalendar tiene en cuenta los días / años bisiestos y otras rarezas de fecha y hora. (Swift 2.2)

let calendar = NSCalendar.currentCalendar()
let rightNow = NSDate()
let interval = 15
let nextDiff = interval - calendar.component(.Minute, fromDate: rightNow) % interval
let nextDate = calendar.dateByAddingUnit(.Minute, value: nextDiff, toDate: rightNow, options: []) ?? NSDate()

Se puede agregar a una extensión en NSDate si es necesario, o como una función de forma libre que devuelve una nueva instancia de NSDate , sea lo que sea que necesite. Espero que esto ayude a cualquiera que lo necesite.

Actualización de Swift 3

let calendar = Calendar.current  
let rightNow = Date()  
let interval = 15  
let nextDiff = interval - calendar.component(.minute, from: rightNow) % interval  
let nextDate = calendar.date(byAdding: .minute, value: nextDiff, to: rightNow) ?? Date()

Answer 17

https://forums.developer.apple.com/thread/92399

ver el enlace para obtener una respuesta completa y detallada de un miembro del personal de Apple. Para ahorrarte un clic, la solución:

let original = Date()

let rounded = Date(timeIntervalSinceReferenceDate: 
(original.timeIntervalSinceReferenceDate / 300.0).rounded(.toNearestOrEven) * 300.0)

Answer 18

- (NSDate *)roundDateToNearestFiveMinutes:(NSDate *)date
{
    NSDateComponents *time = [[NSCalendar currentCalendar]
                              components:NSHourCalendarUnit | NSMinuteCalendarUnit
                              fromDate:date];
    NSInteger minutes = [time minute];
    float minuteUnit = ceil((float) minutes / 5.0);
    minutes = minuteUnit * 5.0;
    [time setMinute: minutes];
    return [[NSCalendar currentCalendar] dateFromComponents:time];
}