swift - 秒表 - 停止和开始

Question

我正在制作一个简单的秒表。我面临的问题是当我再次开始时从上次停止的地方开始/恢复秒表。我试图保留耗时的值，但没有运气

演示=

import UIKit

class ViewController: UIViewController, UITableViewDelegate, UITableViewDataSource  {

    var timer:Timer = Timer()
    var time:Int = 0
    var isActive: Bool = false
    var isReset: Bool = true
    var startTime:TimeInterval?
    var elapsed:TimeInterval?

    var timeInterval:TimeInterval?

    var laps:[String] = [String]()
    var timerDefaults = UserDefaults.standard

    @IBOutlet weak var lapTableView: UITableView!
    @IBOutlet weak var stopwatchLabel: UILabel!
    @IBOutlet weak var labButton: UIButton!
    @IBOutlet weak var startButton: UIButton!



    @IBAction func addLapAction(_ sender: Any) {

        if isActive {
            addLapToTableView()
        } else {
            resetTimer()
        }
    }



    @IBAction func startWatchButton(_ sender: Any) {

        if isActive {
          stopTimer()
        } else {
          startTimer()
        }

    }

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib
        configureTableView()

        startTime = Date.timeIntervalSinceReferenceDate

    }

    func configureTableView() {
        lapTableView.delegate = self
        lapTableView.dataSource = self
    }

    //start timer
    func startTimer() {
         timer = Timer.scheduledTimer(timeInterval: 0.1, target: self, selector: #selector(ViewController.incrementTimer), userInfo: nil, repeats: true)

        isActive = true

        startButton.setTitle("Stop", for: .normal)
        startButton.backgroundColor = UIColor.red

        labButton.setTitle("Lap", for: .normal)

    }

    func funcTimer() {

        timer = Timer.scheduledTimer(timeInterval: 0.1, target: self, selector: #selector(ViewController.incrementTimer), userInfo: nil, repeats: true)
    }

    //stop timer
    func stopTimer() {

        isActive = false
        isReset = false


        timer.invalidate()

        startButton.setTitle("Start", for: .normal)
        startButton.backgroundColor = UIColor.green

        labButton.setTitle("Reset", for: .normal)
    }

    //reset timer
    func resetTimer() {

        isActive = false
        isReset = true

        laps = []
        lapTableView.reloadData()
        stopwatchLabel.text = "00:00:00"
    }

    func incrementTimer() {
        time += 1

        if isReset {
            stopwatchLabel.text = newTime()
        } else {
           stopwatchLabel.text = updateTime()
        }

    }


    //add lap to tableView
    func addLapToTableView() {
        laps.append(stopwatchLabel.text!)
        lapTableView.reloadData()
        print("current lap : \(stopwatchLabel.text!)")
    }


    func displayMinSeconds(time:Int) -> String {

        let minutes:Int = time / 60 % 60
        let seconds:Int = time % 60
        let milliseconds:Int = time * 1000

        return String(format: "%02i:%02i:%02i",  minutes, seconds, milliseconds)
    }


    func newTime() -> String  {
        let currentTime = Date.timeIntervalSinceReferenceDate
        let elapsedTime: TimeInterval = currentTime - startTime!
        return updateTimer(time: elapsedTime)
    }

    func updateTime() -> String {

        return updateTimer(time: elapsed!)
    }

    func updateTimer(time:TimeInterval) -> String {
        var elapsedTime = time

        //calculate the minutes in elapsed time.

        let minutes = UInt8(elapsedTime  / 60.0)
        elapsedTime  -= (TimeInterval(minutes) * 60)

        //calculate the seconds in elapsed time.

        let seconds = UInt8(elapsedTime )

        elapsedTime  -= TimeInterval(seconds)

        //find out the fraction of milliseconds to be displayed.

        let fraction = UInt8(elapsedTime  * 100)

        //add the leading zero for minutes, seconds and millseconds and store them as string constants


        //concatenate minuets, seconds and milliseconds as assign it to the UILabel

        elapsed = elapsedTime
        return String(format: "%02d:%02d:%02d",  minutes, seconds, fraction)

    }



    //MARK - Table View Data Source
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return laps.count
    }


    @objc(tableView:cellForRowAtIndexPath:) func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {

        let cell = tableView.dequeueReusableCell(withIdentifier: "lapCell", for: indexPath)


         cell.textLabel?.text = "lap \(indexPath.row + 1)"

        if indexPath.row == 0 {
            cell.detailTextLabel?.text = ""
        } else {
            cell.detailTextLabel?.text = laps[indexPath.row]
        }



        cell.textLabel?.textColor = UIColor.white
        cell.detailTextLabel?.textColor = UIColor.white

        return cell

    }
}

Answer 1

您在这里所做的是使用递增变量来显示时间，并使用 Date() 引用来计算差异。这确实很难实现，在我构建了一些计时器应用程序之后，我才能告诉您坚持使用任何一种方法都比采用两种方法要好得多。

我强烈推荐的方法是递增变量，它每 0.01 秒运行一个计时器(因为这是您显示的最高小数点)，时间变量是经过了多少 0.01 秒。这样，当您停止/恢复时，您只需重新添加该值，显示耗时就变成了一个简单的数学问题，同时以分钟/秒/小时等形式访问该时间。就我个人而言，我更喜欢这种方法而不是使用 Date()，因为您在如何显示信息方面有更多的自由，您不需要依赖于 Date() 属性的属性类型转换，无论哪种方式，对于简单的用例，您都必须即使您确实使用 Date()，也可以在某处存储数字类型值。因此，对于更简单的计时器应用程序，您可能根本不使用 Date()。

日期似乎更有用的唯一时间是当您需要持久性(保存在文件或数据库中)时。例如，当您想要一个可以关闭并返回到上次中断的位置的计时器时，当您监视位置数据所花费的时间时，以及当您想要稍后可能用于事件分析或用户趋势等的时间数据时。

我能为您想到的使用 Date 的最简单的情况是使用 Date 的 timeIntervalSince1970 属性。当您暂停时，它也不会计算内容，就像递增方法一样节省电池消耗。您仍然需要一个时间增量变量来跟踪记录所花费的时间，以及另一个变量来跟踪暂停时所花费的时间，但如果您尝试同时使用数字和日期，它会有所帮助

var start = Date()
var stopped : Date?
var resumed : Date?
var finished : Date?

var timer : Timer?

var timeElapsed = Double()
var timeStopped = Double()

var actualTimeElapsedInMilliseconds : Int {
    get {
        return Int(timeElapsed - timeStopped)
    }
}

var actualTimeElapsedInTenthOfSecond : Int {
    get {
        return Int((timeElapsed - timeStopped) / 10.0)
    }
}

var actualTimeElapsedInSeconds : Int {
    get {
        return Int((timeElapsed - timeStopped) / 1000)
    }
}


func startTimer() {

    start = Date()
    timer = Timer.init(timeInterval: 0.01, repeats: true, block: { (this) in
        performActiveTimer()
    })

}

func reStartTimer() {

    resumed = Date()
    if let stop = stopped, let resume = resumed {
        timeStopped = timeStopped + (resume.timeIntervalSince1970 - stop.timeIntervalSince1970)
    }
    timer = Timer.init(timeInterval: 0.01, repeats: true, block: { (this) in
        performActiveTimer()
    })

}

func pause() {
    timer?.invalidate()
    stopped = Date()
}

func performActiveTimer() {
    timeElapsed = Date().timeIntervalSince1970 - start.timeIntervalSince1970
    //here i would call you UI update method
}

func terminateTimerAndSave() {
    let now = Date()
    finished = now
    timeElapsed = now.timeIntervalSince1970 - start.timeIntervalSince1970
}

如前所述，使用增量器需要更少的代码，但这种混合方法是创建计时器的最简单方法。顺便说一句，这只是逻辑，您需要使用显示的计算变量来以您想要的方式显示时间。您还需要确保正确地交替使用方法。以避免错误地覆盖可选日期。