SwiftUI - Animating count text from 0 to x

Here's a solution that leverages SwiftUI's built-in animation capabilities. As a result, it doesn't need to manage any timers or animation loops itself.

It's not limited to moving from 0 to a final number, either. Any change in the value performed in a withAnimation block will animate the change in value by moving through intermediate values.

import SwiftUI

struct AnimatedNumberTextView<Content>: View, Animatable where Content: View {
    private var value: Double
    @ViewBuilder private let content: (Int) -> Content
    
    init(_ value: Int, content: @escaping (Int) -> Content) {
        self.value = Double(value)
        self.content = content
    }
    
    var animatableData: Double {
        get { value }
        set { value = newValue }
    }
    
    var body: some View {
        content(Int(value))
    }
}


struct ContentView: View {
    @State private var number = 0
    
    var body: some View {
        HStack {
            Text("Riches:")

            AnimatedNumberTextView(number) { value in
                Text("\(value) 😮")
                    .monospaced()
            }.frame(minWidth: 140, alignment: .trailing)
        }
        .padding(.bottom)
        .onAppear {
            withAnimation(.easeInOut(duration: 2)) {
                number = 87654321
            }
        }
        
        Button("Randomise!") {
            withAnimation(.easeInOut(duration: 1)) {
                number = Int.random(in: 0...87654321)
            }
        }
    }
}

(Inspired by this blog and this blog.)

Here I've created a little function called runCounter which takes a binding to the counter variable, a start value, the end value, and the speed. When called, it sets the bound variable to the start value, and then starts a Timer which runs every speed seconds and increments the counter until it reaches end at which point it invalidates the timer.

This standalone example shows two counters running at different speeds, both of which start when they first appear using .onAppear().

struct ContentView: View {
    @State private var counter1 = 0
    @State private var counter2 = 0
    
    var body: some View {
        VStack {
        Text("\(self.counter1)")
            .onAppear {
                self.runCounter(counter: self.$counter1, start: 0, end: 80, speed: 0.05)
            }
        Text("\(self.counter2)")
            .onAppear {
                self.runCounter(counter: self.$counter2, start: 0, end: 10, speed: 0.5)
            }
        }
    }
    
    func runCounter(counter: Binding<Int>, start: Int, end: Int, speed: Double) {
        counter.wrappedValue = start

        Timer.scheduledTimer(withTimeInterval: speed, repeats: true) { timer in
            counter.wrappedValue += 1
            if counter.wrappedValue == end {
                timer.invalidate()
            }
        }
    }
}

You can use a Timer.Publisher to trigger incrementing of your counter at regular intervals.

To stop incrementing once you reach your desired count, whenever your Timer fires, you can check if count has reached end, if not, increment it, otherwise remove the subscription and hence stop incrementing.

class Counter: ObservableObject {
    @Published var count = 0
    let end: Int

    private var timer = Timer.publish(every: 0.5, on: .main, in: .common).autoconnect()
    private var subscriptions = Set<AnyCancellable>()

    init(end: Int) {
        self.end = end
    }

    func start() {
        timer.sink { [weak self] _ in
            guard let self = self else { return }
            if self.count <=self.end {
                self.count += 1
            } else {
                self.subscriptions.removeAll()
            }
        }.store(in: &subscriptions)
    }
}

struct AnimatedText: View {
    @ObservedObject var counter: Counter

    var body: some View {
        Text("\(counter.count)")
            .onAppear() {
                self.counter.start()
            }
    }
}


struct AnimatedText_Previews: PreviewProvider {
    static var previews: some View {
        AnimatedText(counter: Counter(end: 80))
    }
}

Adding to the answer by @vacawama.

func runCounter(counter: Binding<Int>, start: Int, end: Int, speed: Double) {
    let maxSteps = 20
    counter.wrappedValue = start
    
    let steps = min(abs(end), maxSteps)
    var increment = 1
    if steps == maxSteps {increment = end/maxSteps}

    Timer.scheduledTimer(withTimeInterval: speed, repeats: true) { timer in
        counter.wrappedValue += increment
        if counter.wrappedValue >= end {
            counter.wrappedValue = end
            timer.invalidate()
        }
    }
}

How about this simple solution with a timer:

extension Timer {
    static func scheduledProgressTimer(duration: TimeInterval, block: @escaping ((_ progress: Double) -> Void), completion: (() -> Void)? = nil) {
        let startDate = Date()
        Timer.scheduledTimer(withTimeInterval: 1.0 / 60, repeats: true) { timer in
            let interval = Date().timeIntervalSince(startDate)
            let progress = min(1.0, abs(interval / duration))
            block(progress)
            if progress >= 1.0 {
                timer.invalidate()
                completion?()
            }
        }
    }
}

and then:

struct TestView: View {
    @State var counter: Int = 0
    
    var body: some View {
        VStack {
            Text("Counter: \(counter)")
            Button("Start counting") {
                let endValue = 80
                Timer.scheduledProgressTimer(duration: 2) { progress in
                    counter = Int(progress * Double(endValue))
                } completion: {
                    print("Finished!")
                }
            }
        }
    }
}