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 .