ios - studio - Swift-conversión entera a horas/minutos/segundos

visual studio installer

Question

Tengo una (¿algo?) Pregunta básica sobre las conversiones temporales en Swift .

Tengo un número entero que me gustaría convertir en horas / minutos / segundos.

Ejemplo: Int = 27005 me daría:

7 Hours  30 Minutes 5 Seconds

Sé cómo hacer esto en PHP, pero desafortunadamente Swift no es PHP :-)

¡Cualquier consejo sobre cómo puedo lograr esto rápidamente sería fantástico! ¡Gracias de antemano!

Answer 1

Solución SWIFT 3.0 basada aproximadamente en la que se muestra arriba utilizando extensiones.

extension CMTime {
  var durationText:String {
    let totalSeconds = CMTimeGetSeconds(self)
    let hours:Int = Int(totalSeconds.truncatingRemainder(dividingBy: 86400) / 3600)
    let minutes:Int = Int(totalSeconds.truncatingRemainder(dividingBy: 3600) / 60)
    let seconds:Int = Int(totalSeconds.truncatingRemainder(dividingBy: 60))

    if hours > 0 {
        return String(format: "%i:%02i:%02i", hours, minutes, seconds)
    } else {
        return String(format: "%02i:%02i", minutes, seconds)
    }

  }
}

Úselo con AVPlayer llamándolo así?

 let dTotalSeconds = self.player.currentTime()
 playingCurrentTime = dTotalSeconds.durationText

Answer 2

Aquí hay otra implementación simple en Swift3.

func seconds2Timestamp(intSeconds:Int)->String {
   let mins:Int = intSeconds/60
   let hours:Int = mins/60
   let secs:Int = intSeconds%60

   let strTimestamp:String = ((hours<10) ? "0" : "") + String(hours) + ":" + ((mins<10) ? "0" : "") + String(mins) + ":" + ((secs<10) ? "0" : "") + String(secs)
   return strTimestamp
}

Answer 3

De acuerdo con la respuesta de GoZoner , he escrito una extensión para obtener el formato del tiempo según las horas, los minutos y los segundos:

extension Double {

    func secondsToHoursMinutesSeconds () -> (Int?, Int?, Int?) {
        let hrs = self / 3600
        let mins = (self.truncatingRemainder(dividingBy: 3600)) / 60
        let seconds = (self.truncatingRemainder(dividingBy:3600)).truncatingRemainder(dividingBy:60)
        return (Int(hrs) > 0 ? Int(hrs) : nil , Int(mins) > 0 ? Int(mins) : nil, Int(seconds) > 0 ? Int(seconds) : nil)
    }

    func printSecondsToHoursMinutesSeconds () -> String {

        let time = self.secondsToHoursMinutesSeconds()

        switch time {
        case (nil, let x? , let y?):
            return "/(x) min /(y) sec"
        case (nil, let x?, nil):
            return "/(x) min"
        case (let x?, nil, nil):
            return "/(x) hr"
        case (nil, nil, let x?):
            return "/(x) sec"
        case (let x?, nil, let z?):
            return "/(x) hr /(z) sec"
        case (let x?, let y?, nil):
            return "/(x) hr /(y) min"
        case (let x?, let y?, let z?):
            return "/(x) hr /(y) min /(z) sec"
        default:
            return "n/a"
        }
    }
}

let tmp = 3213123.printSecondsToHoursMinutesSeconds() // "892 hr 32 min 3 sec"

Answer 4

Seguí adelante y creé un cierre para esto (en Swift 3).

let (m, s) = { (secs: Int) -> (Int, Int) in
        return ((secs % 3600) / 60, (secs % 3600) % 60) }(299)

Esto dará m = 4 ys = 59. Así que puedes formatear eso como desees. Por supuesto, puede querer agregar horas también, si no más información.

Answer 5

La forma más simple de imho:

let hours = time / 3600
let minutes = (time / 60) % 60
let seconds = time % 60
return String(format: "%0.2d:%0.2d:%0.2d", hours, minutes, seconds)

Answer 6

En macOS 10.10+ / iOS 8.0+ (NS)DateComponentsFormatter se ha introducido para crear una cadena legible.

Considera la configuración regional del usuario y el idioma.

let interval = 27005

let formatter = DateComponentsFormatter()
formatter.allowedUnits = [.hour, .minute, .second]
formatter.unitsStyle = .full

let formattedString = formatter.string(from: TimeInterval(interval))!
print(formattedString)

Los estilos de unidad disponibles son positional , abbreviated , short , full , spellOut y brief .

Para obtener más información, lea la documentación .

Answer 7

NSTimeInterval es Double , hazlo con la extensión. Ejemplo:

extension Double {

    var formattedTime: String {

        var formattedTime = "0:00"

        if self > 0 {

            let hours = Int(self / 3600)
            let minutes = Int(truncatingRemainder(dividingBy: 3600) / 60)

            formattedTime = String(hours) + ":" + (minutes < 10 ? "0" + String(minutes) : String(minutes))
        }

        return formattedTime
    }
}

Answer 8

Creé una mezcla de respuestas existentes para simplificar todo y reducir la cantidad de código necesario para Swift 3 .

func hmsFrom(seconds: Int, completion: @escaping (_ hours: Int, _ minutes: Int, _ seconds: Int)->()) {

        completion(seconds / 3600, (seconds % 3600) / 60, (seconds % 3600) % 60)

}

func getStringFrom(seconds: Int) -> String {

    return seconds < 10 ? "0/(seconds)" : "/(seconds)"
}

Uso:

var seconds: Int = 100

hmsFrom(seconds: seconds) { hours, minutes, seconds in

    let hours = getStringFrom(seconds: hours)
    let minutes = getStringFrom(seconds: minutes)
    let seconds = getStringFrom(seconds: seconds)

    print("/(hours):/(minutes):/(seconds)")                
}

Huellas dactilares:

00:01:40

Answer 9

Definir

func secondsToHoursMinutesSeconds (seconds : Int) -> (Int, Int, Int) {
  return (seconds / 3600, (seconds % 3600) / 60, (seconds % 3600) % 60)
}

Utilizar

> secondsToHoursMinutesSeconds(27005)
(7,30,5)

o

let (h,m,s) = secondsToHoursMinutesSeconds(27005)

La función anterior hace uso de tuplas Swift para devolver tres valores a la vez. Usted desestructura la tupla usando la sintaxis let (var, ...) o puede acceder a miembros tuple individuales, si es necesario.

Si realmente necesita imprimirlo con las palabras Hours etc., utilice algo como esto:

func printSecondsToHoursMinutesSeconds (seconds:Int) -> () {
  let (h, m, s) = secondsToHoursMinutesSeconds (seconds)
  print ("/(h) Hours, /(m) Minutes, /(s) Seconds")
}

Tenga en cuenta que la implementación anterior de secondsToHoursMinutesSeconds() funciona para los argumentos Int . Si desea una versión Double , tendrá que decidir cuáles son los valores de retorno: podría ser (Int, Int, Double) o podría ser (Double, Double, Double) . Podrías probar algo como:

func secondsToHoursMinutesSeconds (seconds : Double) -> (Double, Double, Double) {
  let (hr,  minf) = modf (seconds / 3600)
  let (min, secf) = modf (60 * minf)
  return (hr, min, 60 * secf)
}

Answer 10

Aquí hay un enfoque más estructurado / flexible: (Swift 3)

struct StopWatch {

    var totalSeconds: Int

    var years: Int {
        return totalSeconds / 31536000
    }

    var days: Int {
        return (totalSeconds % 31536000) / 86400
    }

    var hours: Int {
        return (totalSeconds % 86400) / 3600
    }

    var minutes: Int {
        return (totalSeconds % 3600) / 60
    }

    var seconds: Int {
        return totalSeconds % 60
    }

    //simplified to what OP wanted
    var hoursMinutesAndSeconds: (hours: Int, minutes: Int, seconds: Int) {
        return (hours, minutes, seconds)
    }
}

let watch = StopWatch(totalSeconds: 27005 + 31536000 + 86400)
print(watch.years) // Prints 1
print(watch.days) // Prints 1
print(watch.hours) // Prints 7
print(watch.minutes) // Prints 30
print(watch.seconds) // Prints 5
print(watch.hoursMinutesAndSeconds) // Prints (7, 30, 5)

Tener un enfoque como este permite agregar análisis de conveniencia como este:

extension StopWatch {

    var simpleTimeString: String {
        let hoursText = timeText(from: hours)
        let minutesText = timeText(from: minutes)
        let secondsText = timeText(from: seconds)
        return "/(hoursText):/(minutesText):/(secondsText)"
    }

    private func timeText(from number: Int) -> String {
        return number < 10 ? "0/(number)" : "/(number)"
    }
}
print(watch.simpleTimeString) // Prints 07:30:05

Debe tenerse en cuenta que los enfoques basados ​​exclusivamente en Entero no tienen en cuenta día / segundo intercalar. Si el caso de uso trata con fechas / horas reales, se debe usar la fecha y el calendario .