Introduction

TextField is a text control, so SwiftUI naturally works best with Binding<String>. But SwiftUI also supports numeric bindings when you use the right initializer. The practical choice depends on whether your value is required, optional, or needs custom validation while the user is typing.

Direct Numeric Binding

SwiftUI has a TextField initializer that accepts a typed binding and a format style. That lets you bind directly to an integer.

1import SwiftUI
2
3struct QuantityView: View {
4    @State private var quantity = 3
5
6    var body: some View {
7        TextField("Quantity", value: $quantity, format: .number)
8            .keyboardType(.numberPad)
9            .textFieldStyle(.roundedBorder)
10            .padding()
11    }
12}

This is the cleanest approach when the field is definitely an Int and simple numeric editing is enough.

String Bridge for Editing

Real text editing has intermediate states that are not always valid integers. Users may temporarily type an empty field, a minus sign, or partially edited content, so many SwiftUI forms still bridge through String.

1import SwiftUI
2
3struct QuantityEditor: View {
4    @State private var quantity = 3
5    @State private var text = "3"
6
7    var body: some View {
8        TextField("Quantity", text: $text)
9            .keyboardType(.numberPad)
10            .textFieldStyle(.roundedBorder)
11            .padding()
12            .onChange(of: text) { _, newValue in
13                if let value = Int(newValue) {
14                    quantity = value
15                }
16            }
17    }
18}

This pattern is more forgiving because the field can hold temporarily invalid text while the model updates only when conversion succeeds.

Creating a Custom Binding

If you already have an Int in state but want text-style control, build a custom Binding<String>.

1import SwiftUI
2
3struct QuantityBindingView: View {
4    @State private var quantity = 7
5
6    var quantityText: Binding<String> {
7        Binding(
8            get: { String(quantity) },
9            set: { newValue in
10                if let value = Int(newValue) {
11                    quantity = value
12                } else if newValue.isEmpty {
13                    quantity = 0
14                }
15            }
16        )
17    }
18
19    var body: some View {
20        TextField("Quantity", text: quantityText)
21            .keyboardType(.numberPad)
22            .textFieldStyle(.roundedBorder)
23            .padding()
24    }
25}

This keeps the storage type numeric while letting you define exactly how invalid or empty input should behave.

Optional Integers Need a Different Rule

If the field is allowed to be blank, 0 is not the same as "no value." Model that explicitly with Int?.

1import SwiftUI
2
3struct OptionalQuantityView: View {
4    @State private var quantity: Int? = nil
5
6    var quantityText: Binding<String> {
7        Binding(
8            get: { quantity.map(String.init) ?? "" },
9            set: { newValue in
10                quantity = Int(newValue)
11            }
12        )
13    }
14
15    var body: some View {
16        TextField("Optional quantity", text: quantityText)
17            .keyboardType(.numberPad)
18            .textFieldStyle(.roundedBorder)
19            .padding()
20    }
21}

Now an empty field maps to nil instead of forcing a made-up integer value.

Validation and Range Checks

Numeric input often needs more than parsing. It may also need a business rule.

1import SwiftUI
2
3struct AgeView: View {
4    @State private var age = 18
5
6    var ageText: Binding<String> {
7        Binding(
8            get: { String(age) },
9            set: { newValue in
10                if let value = Int(newValue), (0...130).contains(value) {
11                    age = value
12                }
13            }
14        )
15    }
16
17    var body: some View {
18        TextField("Age", text: ageText)
19            .keyboardType(.numberPad)
20            .textFieldStyle(.roundedBorder)
21            .padding()
22    }
23}

This kind of rule is easier to express with a custom binding than with the simplest typed initializer.

Choosing the Right Approach

Use direct numeric binding when:

• the field is simple
• invalid intermediate states are not a problem
• you want minimal glue code

Use a string bridge or custom binding when:

• the field may be blank
• editing should tolerate temporary invalid content
• you need range checks or custom conversion rules

The right answer is not just about what compiles. It is about what editing behavior feels correct to the user.

Common Pitfalls

• Expecting a strict Binding<Int> to behave perfectly through every intermediate keystroke.
• Converting invalid input directly to 0, which can silently change meaning.
• Using a non-optional Int when the field is allowed to be empty.
• Forgetting to set a numeric keyboard type for number-focused input.
• Spreading conversion logic inline through the view instead of wrapping it in a named custom binding when the rules get more complex.

Summary

• SwiftUI can bind a TextField directly to an integer with the typed value initializer.
• A String bridge is often more flexible for real editing behavior.
• Custom bindings let you keep integer state while controlling conversion rules.
• Optional numeric fields should usually map empty text to nil, not to 0.
• Pick the approach based on user editing behavior, not only on type strictness.