Stepper

A control that performs increment and decrement actions.

ComponentiOS 13.0+macOS 10.15+watchOS 9.0+Stepper in SwiftUI

Declaration

React
import { Stepper } from 'swiftui-react-native';
Swift
nonisolated struct Stepper<Label> where Label : View

Initializers

6 SwiftUI initializers back <Stepper>. The props you pass pick one.

React
<Stepper
  value: Binding<any>
  step?: number
  onEditingChanged?: (arg0: boolean) => void
>
  children?: ReactNode
</Stepper>
Swift
@export(implementation) nonisolated init<V>(
    value: Binding<V>,
    step: V.Stride = 1,
    @ContentBuilder label: () -> Label,
    onEditingChanged: @escaping (Bool) -> Void = { _ in }
)
where V : Strideable
  • value*Binding<any>

    The Binding to a value that you provide.

  • stepnumber

    The amount to increment or decrement value each time the user clicks or taps the stepper's increment or decrement buttons. Defaults to 1.

    Default `1`

  • childrenReactNode

    Content. Strings become Text; React Native views are laid out by Yoga and placed by SwiftUI.

    Swift label: () -> Label

  • onEditingChanged(arg0: boolean) => void

    A closure that's called when editing begins and ends. For example, on iOS, the user may touch and hold the increment or decrement buttons on a stepper which causes the execution of the onEditingChanged closure at the start and end of the gesture.

    Default `{ _ in }`

Also takes the common view props: modifiers, style and testID.

Overview

Use a stepper control when you want the user to have granular control while incrementing or decrementing a value. For example, you can use a stepper to:

  • Change a value up or down by 1.
  • Operate strictly over a prescribed range.
  • Step by specific amounts over a stepper's range of possible values.

The example below uses an array that holds a number of Color values, a local state variable, value, to set the control's background color, and title label. When the user clicks or taps the stepper's increment or decrement buttons, SwiftUI executes the relevant closure that updates value, wrapping the value to prevent overflow. SwiftUI then re-renders the view, updating the text and background color to match the current index:

struct StepperView: View {
    @State private var value = 0
    let colors: [Color] = [.orange, .red, .gray, .blue,
                           .green, .purple, .pink]

    func incrementStep() {
        value += 1
        if value >= colors.count { value = 0 }
    }

    func decrementStep() {
        value -= 1
        if value < 0 { value = colors.count - 1 }
    }

    var body: some View {
        Stepper {
            Text("Value: \(value) Color: \(colors[value].description)")
        } onIncrement: {
            incrementStep()
        } onDecrement: {
            decrementStep()
        }
        .padding(5)
        .background(colors[value])
    }
}

The following example shows a stepper that displays the effect of incrementing or decrementing a value with the step size of step with the bounds defined by range:

struct StepperView: View {
    @State private var value = 0
    let step = 5
    let range = 1...50

    var body: some View {
        Stepper(
            value: $value,
            in: range,
            step: step
        ) {
            Text("Current: \(value) in \(range.description) " +
                 "stepping by \(step)")
        }
        .padding(10)
    }
}

From Apple’s SwiftUI documentation. Code samples there are Swift.

Relationships

Conforms to

  • View

See also

More in Controls.