स्विफ्ट - घंटे / मिनट / सेकंड के लिए पूर्णांक रूपांतरण

Question

स्विफ्ट में समय रूपांतरणों के संबंध में मेरा (कुछ हद तक) मूल प्रश्न है ।

मेरे पास एक पूर्णांक है जिसे मैं घंटो / मिनट / सेकंड में परिवर्तित करूँगा।

उदाहरण: Int = 27005 मुझे देना होगा:

7 Hours  30 Minutes 5 Seconds

मुझे पता है कि PHP में यह कैसे करना है, लेकिन अफसोस, PHP PHP नहीं है

कैसे मैं इसे तेजी से प्राप्त कर सकता हूँ पर कोई सुझाव शानदार होगा! आपका अग्रिम में ही बहुत धन्यवाद!

Answer 1

परिभाषित करें

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

उपयोग

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

या

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

उपरोक्त फ़ंक्शन एक बार में तीन मान वापस करने के लिए स्विफ्ट ट्यूपल्स का उपयोग करता है। आप let (var, ...)सिंटैक्स का उपयोग करके टपल को नष्ट कर देते हैं या ज़रूरत पड़ने पर व्यक्तिगत टपल सदस्यों तक पहुँच सकते हैं।

यदि आपको वास्तव में इसे शब्दों Hoursआदि के साथ प्रिंट करने की आवश्यकता है तो कुछ इस तरह का उपयोग करें:

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

ध्यान दें कि तर्कों के secondsToHoursMinutesSeconds()लिए कार्यों का उपरोक्त कार्यान्वयन Int। यदि आप एक Doubleसंस्करण चाहते हैं तो आपको यह तय करने की आवश्यकता होगी कि रिटर्न मान क्या हैं - हो सकते हैं (Int, Int, Double)या हो सकते हैं (Double, Double, Double)। आप कुछ इस तरह की कोशिश कर सकते हैं:

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

Comments

अंतिम मान (seconds % 3600) % 60को अनुकूलित किया जा सकता है seconds % 60। पहले घंटे निकालने की जरूरत नहीं है।

— zisoft

@GoZoner - मुझे ठीक से काम करने के लिए PrintSecondsToHoursMinutesSeconds फ़ंक्शन नहीं मिल रहा है। यह वही है जो मेरे पास एक खेल के मैदान में है, लेकिन PrintSecondsToHoursMinutesSeconds कुछ भी नहीं लौटा रहा है: आयात UIKit func secondsToHoursMinutesSeconds (सेकंड: Int) -> (Int, Int) {रिटर्न / 36 सेकंड, (सेकंड% 3600) / 60 (सेकंड) % 3600)% 60)} let (h, m, s) = secondsToHoursMinutesSeconds (27005) funcecondsToHoursMinutesSeconds (सेकंड: Int) -> () {{चलो (m, s) = secondsToHoursMinutesSeconds (सेकंड) प्रिंट करें ) घंटे, (एम) मिनट, (एस) सेकंड्स)}

— जो

printSecondstoHoursMinutesSeconds()कुछ भी वापस नहीं करता है ( -> ()फ़ंक्शन घोषणा में वापसी प्रकार देखें )। फ़ंक्शन कुछ प्रिंट करता है; जो एक खेल के मैदान में दिखाई नहीं देता है। यदि आप चाहते हैं कि यह कुछ वापस लौटे, Stringतो println()कॉल को समाप्त करें और फ़ंक्शन के रिटर्न प्रकार को ठीक करें।

— गोजोनर

@GoZoner - उपरोक्त सिंटैक्स में सिर्फ एक त्वरित प्रश्न। मैं उस 27005 को एक चर में कैसे घोषित करूंगा? मैं अभी एक ऐसे उपकरण पर काम कर रहा हूं जो मेरे पैरों को तेजी से गीला कर सकता है। मेरे पास एक स्थिर है जो सेकंड की मात्रा प्रदर्शित करता है (मेरी मूल गणना के बाद उत्पन्न)। आज्ञा देना cocSeconds = cocMinutes * 60. (cocSeconds है जो मैं 27005 के स्थान पर उपयोग करना चाहता हूं।) मुझे लगता है कि मुझे जो समस्या हो रही है वह है cocSeconds एक डबल है, और आपके सिंटैक्स में, आप Ints का उपयोग कर रहे हैं। 27005 के स्थान पर एक चर लगाने के लिए मैं इस कोड को समायोजित करने के बारे में कैसे जाऊँगा? अग्रिम में बहुत बहुत धन्यवाद!!!

— जो

मैंने जो समाधान दिया Intहै वह प्रकृति /और %कार्यों के कारण प्रकारों के लिए काम करता है। यह /गुटीय भाग को गिराता है। समान कोड काम नहीं करेगा Double। विशेष रूप से 2 == 13/5 लेकिन 2.6 == 13.0 / 5। इसलिए आपको इसके लिए एक अलग कार्यान्वयन की आवश्यकता होगी Double। मैंने इस पर एक नोट के साथ अपना जवाब अपडेट किया है।

— गोजोनर

Answer 2

MacOS में 10.10+ / iOS 8.0+ (NS)DateComponentsFormatterएक पठनीय स्ट्रिंग बनाने के लिए पेश किया गया है।

यह उपयोगकर्ता की स्थानीय भाषा को अवांछित भाषा मानता है।

let interval = 27005

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

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

उपलब्ध इकाई शैलियों रहे हैं positional, abbreviated, short, full, spellOutऔर brief।

अधिक जानकारी के लिए कृपया डोक्यूमिनेशन पढ़ें ।

Comments

उपयोग करने formatter.unitsStyle = .positionalसे वास्तव में मुझे जो चाहिए (जो है 7:30:05) देता है! सर्वश्रेष्ठ उत्तर IMO

— सैम

और आप शून्य `` `formatter.zeroFormattingBehavior = .pad` `` जोड़ सकते हैं

— Eduardo Irias

इसका उल्टा लाभ कैसे प्राप्त करें। यह कैसे घंटे, मिनटों सेकंड में बदलने के लिए है

— एंजल एफ साइरस

@AngelFSyrus सिंपलhours * 3600 + minutes * 60

— vadian

Answer 3

वदियान के उत्तर पर निर्माण करते हुए , मैंने एक एक्सटेंशन लिखा, Doubleजिसमें TimeIntervalसे एक ( एक प्रकार का उपनाम है) लेता है और एक स्ट्रिंग स्वरूपित करता है।

extension Double {
  func asString(style: DateComponentsFormatter.UnitsStyle) -> String {
    let formatter = DateComponentsFormatter()
    formatter.allowedUnits = [.hour, .minute, .second, .nanosecond]
    formatter.unitsStyle = style
    guard let formattedString = formatter.string(from: self) else { return "" }
    return formattedString
  }
}

विभिन्न DateComponentsFormatter.UnitsStyleविकल्प इस प्रकार हैं:

10000.asString(style: .positional)  // 2:46:40
10000.asString(style: .abbreviated) // 2h 46m 40s
10000.asString(style: .short)       // 2 hr, 46 min, 40 sec
10000.asString(style: .full)        // 2 hours, 46 minutes, 40 seconds
10000.asString(style: .spellOut)    // two hours, forty-six minutes, forty seconds
10000.asString(style: .brief)       // 2hr 46min 40sec

Comments

@MaksimKniazev आमतौर पर समय-उन्मुख मूल्यों का प्रतिनिधित्व Doublesस्विफ्ट द्वारा किया जाता है।

— एड्रियन

@ एड्रियन विस्तार के लिए धन्यवाद। मुझे .positional UnitStyle पसंद है, हालाँकि मैं इसे प्रदर्शित करना चाहूँगा अर्थात: 9 सेकंड "00:09" के बजाय "9", 1min 25 सेकंड "1:25" के बजाय "1:25"। मैं इस गणना को मैन्युअल रूप से प्राप्त करने में सक्षम हूं, दोहरे मूल्य के आधार पर और मैं सोच रहा था कि क्या विस्तार में खुद को शामिल करने का कोई तरीका है? धन्यवाद।

— वेटुका

FYI करें: यदि आप एक एकल अंक मूल्य से पहले 0s रखना चाहते हैं (या 0 मूल्य है बस हो) तो आप इस जोड़ने की जरूरत है formatter.zeroFormattingBehavior = .pad। : यह हमें देना होगा3660.asString(style: .positional) // 01:01:00

— Moucheg

Answer 4

मैंने सब कुछ सरल बनाने और स्विफ्ट 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)"
}

उपयोग:

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)")                
}

प्रिंटों:

00:01:40

Comments

मेरे दृष्टिकोण से, क्लोजर जोड़ना वास्तव में कुछ भी सरल नहीं है। क्या बंद होने का कोई अच्छा कारण है?

— derpoliuk

@derpoliuk मुझे अपने ऐप में अपनी विशिष्ट आवश्यकताओं के लिए क्लोजर की आवश्यकता है

— डेविड सीक

Answer 5

यहाँ एक अधिक संरचित / लचीला दृष्टिकोण है: (स्विफ्ट 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)

इस तरह एक दृष्टिकोण होने से इस तरह की सुविधा को जोड़ने की अनुमति मिलती है:

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

यह ध्यान दिया जाना चाहिए कि विशुद्ध रूप से पूर्णांक आधारित दृष्टिकोण लीप डे / सेकंड को ध्यान में नहीं रखते हैं। यदि उपयोग मामला वास्तविक तिथियों / समय के साथ काम कर रहा है तो दिनांक और कैलेंडर का उपयोग किया जाना चाहिए।

Comments

क्या आप कृपया monthअपने कार्यान्वयन में जोड़ सकते हैं? अग्रिम में धन्यवाद!

— ixany

आपको कुछ इस तरह के लिए NSCalendar (कैलेंडर) का उपयोग करना चाहिए।

— NoLongerContributingToSE 16

आप return number < 10 ? "0\(number)" : "\(number)"एक स्ट्रिंग फॉर्मेटर का उपयोग करके प्रतिस्थापित कर सकते हैं return String(format: "%02d", number)जो स्वचालित रूप से एक शून्य जोड़ता है जब संख्या 10 से नीचे होती है

— कॉन्टिनम

Answer 6

स्विफ्ट 5 में:

    var i = 9897

    func timeString(time: TimeInterval) -> String {
        let hour = Int(time) / 3600
        let minute = Int(time) / 60 % 60
        let second = Int(time) % 60

        // return formated string
        return String(format: "%02i:%02i:%02i", hour, minute, second)
    }

फ़ंक्शन को कॉल करने के लिए

    timeString(time: TimeInterval(i))

02:44:57 पर लौटेंगे

Comments

उत्तम! बस मुझे जो चाहिए था। मैंने एक इंट चर के लिए 9897 को बदल दिया और वांछित परिणाम प्राप्त किए। धन्यवाद!

— डेविड_2877

Answer 7

स्विफ्ट 4

func formatSecondsToString(_ seconds: TimeInterval) -> String {
    if seconds.isNaN {
        return "00:00"
    }
    let Min = Int(seconds / 60)
    let Sec = Int(seconds.truncatingRemainder(dividingBy: 60))
    return String(format: "%02d:%02d", Min, Sec)
}

Comments

TruncatingRemainder क्या है? Xcode मेरे लिए इसे नहीं पहचानता है।

— अल्फी जूल

Answer 8

यहाँ 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 9

एक्सटेंशन का उपयोग करके ऊपर दिए गए मोटे तौर पर आधारित स्विफ्ट 3.0 समाधान।

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)
    }

  }
}

AVPlayer के साथ इसका उपयोग इस तरह से करें?

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

Answer 10

मैंने इसी तरह के सवाल का जवाब दिया था , हालांकि आपको परिणाम में मिलीसेकंड प्रदर्शित करने की आवश्यकता नहीं है। इसलिए मेरे समाधान के लिए आईओएस 10.0, टीवीओएस 10.0, वॉचओएस 3.0 या मैकओएस 10.12 की आवश्यकता है।

आपको func convertDurationUnitValueToOtherUnits(durationValue:durationUnit:smallestUnitDuration:)उस उत्तर से कॉल करना चाहिए जिसका मैंने पहले ही उल्लेख किया था:

let secondsToConvert = 27005
let result: [Int] = convertDurationUnitValueToOtherUnits(
    durationValue: Double(secondsToConvert),
    durationUnit: .seconds,
    smallestUnitDuration: .seconds
)
print("\(result[0]) hours, \(result[1]) minutes, \(result[2]) seconds") // 7 hours, 30 minutes, 5 seconds

Answer 11

स्विफ्ट 5:

extension Int {

    func secondsToTime() -> String {

        let (h,m,s) = (self / 3600, (self % 3600) / 60, (self % 3600) % 60)

        let h_string = h < 10 ? "0\(h)" : "\(h)"
        let m_string =  m < 10 ? "0\(m)" : "\(m)"
        let s_string =  s < 10 ? "0\(s)" : "\(s)"

        return "\(h_string):\(m_string):\(s_string)"
    }
}

उपयोग:

let seconds : Int = 119
print(seconds.secondsToTime()) // Result = "00:01:59"

Answer 12

GoZoner जवाब के अनुसार मैंने समय , मिनट और सेकंड के अनुसार स्वरूपित करने के लिए एक एक्सटेंशन लिखा है :

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 13

यहाँ मैं स्विफ्ट 4+ में अपने म्यूजिक प्लेयर के लिए क्या उपयोग करता हूं। मैं सेकंड परिवर्तित कर रहा हूँ इंट पठनीय करने के लिए स्ट्रिंग प्रारूप

extension Int {
    var toAudioString: String {
        let h = self / 3600
        let m = (self % 3600) / 60
        let s = (self % 3600) % 60
        return h > 0 ? String(format: "%1d:%02d:%02d", h, m, s) : String(format: "%1d:%02d", m, s)
    }
}

इस तरह का उपयोग करें:

print(7903.toAudioString)

आउटपुट: 2:11:43

Answer 14

@ R3dm4n का उत्तर बहुत अच्छा था। हालाँकि, मुझे इसमें भी घंटे की आवश्यकता थी। बस किसी और के मामले में यहाँ भी जरूरत है:

func formatSecondsToString(_ seconds: TimeInterval) -> String {
    if seconds.isNaN {
        return "00:00:00"
    }
    let sec = Int(seconds.truncatingRemainder(dividingBy: 60))
    let min = Int(seconds.truncatingRemainder(dividingBy: 3600) / 60)
    let hour = Int(seconds / 3600)
    return String(format: "%02d:%02d:%02d", hour, min, sec)
}

Answer 15

नवीनतम कोड: XCode 10.4 स्विफ्ट 5

extension Int {
    func timeDisplay() -> String {
        return "\(self / 3600):\((self % 3600) / 60):\((self % 3600) % 60)"
    }
}

Answer 16

स्विफ्ट 5 और स्ट्रिंग रिस्पॉन्स, प्रेजेंटेबल फॉर्मेट में

public static func secondsToHoursMinutesSecondsStr (seconds : Int) -> String {
      let (hours, minutes, seconds) = secondsToHoursMinutesSeconds(seconds: seconds);
      var str = hours > 0 ? "\(hours) h" : ""
      str = minutes > 0 ? str + " \(minutes) min" : str
      str = seconds > 0 ? str + " \(seconds) sec" : str
      return str
  }

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

उपयोग:

print(secondsToHoursMinutesSecondsStr(seconds: 20000)) // Result = "5 h 33 min 20 sec"

Answer 17

सबसे सरल तरीका 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)

Comments

यह इंट के ldबजाय डबल के लिए हो सकता है d।

— निक कोव

Answer 18

NSTimeIntervalहै Doubleविस्तार के साथ यह क्या करते हो। उदाहरण:

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 19

मैंने आगे बढ़कर (स्विफ्ट 3 में) इसके लिए एक क्लोजर बनाया।

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

यह m = 4 और s = 59 देगा। इसलिए आप अपनी इच्छानुसार प्रारूपित कर सकते हैं। यदि आप अधिक जानकारी नहीं चाहते हैं, तो आप निश्चित रूप से घंटों को जोड़ना चाहते हैं।

Answer 20

स्विफ्ट 4 मैं इस एक्सटेंशन का उपयोग कर रहा हूं

 extension Double {

    func stringFromInterval() -> String {

        let timeInterval = Int(self)

        let millisecondsInt = Int((self.truncatingRemainder(dividingBy: 1)) * 1000)
        let secondsInt = timeInterval % 60
        let minutesInt = (timeInterval / 60) % 60
        let hoursInt = (timeInterval / 3600) % 24
        let daysInt = timeInterval / 86400

        let milliseconds = "\(millisecondsInt)ms"
        let seconds = "\(secondsInt)s" + " " + milliseconds
        let minutes = "\(minutesInt)m" + " " + seconds
        let hours = "\(hoursInt)h" + " " + minutes
        let days = "\(daysInt)d" + " " + hours

        if daysInt          > 0 { return days }
        if hoursInt         > 0 { return hours }
        if minutesInt       > 0 { return minutes }
        if secondsInt       > 0 { return seconds }
        if millisecondsInt  > 0 { return milliseconds }
        return ""
    }
}

उपयोग के

// assume myTimeInterval = 96460.397    
myTimeInteval.stringFromInterval() // 1d 2h 47m 40s 397ms

Answer 21

नेक का जवाब सही नहीं है।

यहाँ एक सही संस्करण है

func seconds2Timestamp(intSeconds:Int)->String {
   let mins:Int = (intSeconds/60)%60
   let hours:Int = intSeconds/3600
   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 22

एक और तरीका है कि सेकंड्स को डेट में कन्वर्ट किया जाएगा और डेट से ही सेकंड्स, मिनट्स और ऑवर को कंपोनेंट लिया जाएगा। इस समाधान में केवल 23:59:59 तक सीमा है