Android Academy · Lektion

Eingaben validieren

Eingaben prüfen und hilfreiche Fehler anzeigen

Eingaben validieren ist eine kostenlose Android Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Android Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Android Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum Eingaben validieren

Benutzer machen Fehler: ein leerer Name, eine fehlerhafte E-Mail-Adresse oder ein zu kurzes Passwort. Gute Formulare erkennen solche Fehler frühzeitig und erklären verständlich, was korrigiert werden muss.

In dieser Lektion fügen Sie Compose-Formularen eine Validierung hinzu, zeigen Inline-Fehler an und deaktivieren die Schaltfläche zum Absenden, bis alles gültig ist.

Eine Validierungsregel ist einfach eine Funktion

Halten Sie die Validierungslogik in einfachen Kotlin-Funktionen, die einen Wert entgegennehmen und zurückgeben, ob er gültig ist (oder eine Fehlermeldung). Dadurch lassen sich Regeln wiederverwenden und einfach testen.

Hier sehen Sie eine einfache Prüfung für eine E-Mail-Adresse.

fun emailError(email: String): String? = when {
    email.isBlank() -> "Email is required"
    !email.contains("@") -> "Enter a valid email"
    else -> null
}

Den Fehler am Feld anzeigen

OutlinedTextField verfügt über ein isError-Flag und einen supportingText-Slot. Kombinieren Sie beide, um ein rotes Feld mit einer Meldung darunter anzuzeigen.

Der Fehler stammt direkt aus Ihrer Validierungsfunktion.

var email by remember { mutableStateOf("") }
val error = emailError(email)

OutlinedTextField(
    value = email,
    onValueChange = { email = it },
    label = { Text("Email") },
    isError = error != null,
    supportingText = { if (error != null) Text(error) }
)

Nicht zu früh Alarm schlagen

„E-Mail-Adresse ist erforderlich“ anzuzeigen, bevor der Benutzer das Feld überhaupt berührt hat, wirkt unfreundlich. Häufig verfolgt man deshalb, ob ein Feld berührt wurde, und zeigt Fehler erst danach an.

Hier markieren wir das Feld als berührt, sobald es den Fokus verliert.

var email by remember { mutableStateOf("") }
var touched by remember { mutableStateOf(false) }
val error = if (touched) emailError(email) else null

OutlinedTextField(
    value = email,
    onValueChange = { email = it },
    label = { Text("Email") },
    isError = error != null,
    modifier = Modifier.onFocusChanged {
        if (!it.isFocused) touched = true
    }
)

Ein Passwort validieren

Passwörter unterliegen meist mehreren Regeln. Geben Sie die erste Regel zurück, die fehlschlägt, damit der Benutzer jeweils nur eine Sache korrigieren muss.

Beachten Sie, dass dies weiterhin eine reine Funktion ohne UI ist.

fun passwordError(pw: String): String? = when {
    pw.length < 8 -> "At least 8 characters"
    pw.none { it.isDigit() } -> "Add a number"
    pw.none { it.isUpperCase() } -> "Add an uppercase letter"
    else -> null
}

Feldübergreifende Validierung

Manche Regeln beziehen sich auf zwei Felder, etwa „Passwort bestätigen muss mit dem Passwort übereinstimmen“. Solche Regeln können nicht in einer Funktion für ein einzelnes Feld enthalten sein. Berechnen Sie sie daher dort, wo beide Werte verfügbar sind.

var password by remember { mutableStateOf("") }
var confirm by remember { mutableStateOf("") }

val confirmError =
    if (confirm.isNotEmpty() && confirm != password)
        "Passwords don't match"
    else null

Absenden deaktivieren, bis alles gültig ist

Das gesamte Formular ist gültig, wenn jede Regel erfüllt ist. Berechnen Sie einen einzelnen booleschen Wert und verwenden Sie ihn, um die Schaltfläche zum Absenden zu aktivieren oder zu deaktivieren.

So verhindern Sie von vornherein, dass der Benutzer ungültige Daten absendet.

val formValid =
    emailError(email) == null &&
    passwordError(password) == null &&
    confirmError == null

Button(onClick = { submit() }, enabled = formValid) {
    Text("Create Account")
}

Beim Absenden validieren

Die Inline-Validierung unterstützt den Benutzer, aber Sie sollten beim Drücken der Schaltfläche zum Absenden zusätzlich alles erneut prüfen. Der Submit-Handler entscheidet, ob fortgefahren wird oder alle Fehler gleichzeitig angezeigt werden.

fun onSubmit() {
    val errors = listOfNotNull(
        emailError(email),
        passwordError(password)
    )
    if (errors.isEmpty()) {
        register(email, password)
    } else {
        // show errors / mark fields touched
    }
}

Eingabemöglichkeiten einschränken

Validierung kann auch vorbeugend erfolgen. Bei einer Telefonnummer ignorieren Sie innerhalb von onValueChange einfach Zeichen, die keine Ziffern sind, sodass die ungültige Eingabe gar nicht erst in den Zustand gelangt.

Das ist benutzerfreundlicher, als den Benutzer anschließend zu tadeln.

var phone by remember { mutableStateOf("") }

OutlinedTextField(
    value = phone,
    onValueChange = { input ->
        phone = input.filter { it.isDigit() }.take(10)
    },
    label = { Text("Phone") }
)

Validierung im ViewModel zentralisieren

Halten Sie die Validierung bei echten Bildschirmen im ViewModel, sodass die UI nur die Ergebnisse anzeigt. Das ViewModel stellt Fehler und ein isValid-Flag bereit.

So bleiben Composables übersichtlich und Ihre Regeln können als Unit-Tests geprüft werden.

class SignUpViewModel : ViewModel() {
    var email by mutableStateOf("")
        private set

    val emailError: String?
        get() = emailError(email)

    val isValid: Boolean
        get() = emailError == null && email.isNotBlank()

    fun onEmailChange(value: String) { email = value }
}

Reines Kotlin: Regeln testen

Da Validatoren reine Funktionen sind, können Sie sie überall ausführen. Hier werden die Regeln für E-Mail-Adresse und Passwort eigenständig ausgeführt, genau wie in einem Unit-Test.

fun emailError(email: String): String? = when {
    email.isBlank() -> "Email is required"
    !email.contains("@") -> "Enter a valid email"
    else -> null
}

fun main() {
    println(emailError(""))
    println(emailError("nope"))
    println(emailError("ada@dev.io"))
}

Kurze Überprüfung

Welches Eigenschaftspaar von OutlinedTextField wird verwendet, um ein Feld als ungültig zu markieren und darunter eine Meldung anzuzeigen?

Zusammenfassung

Sie können Compose-Formulare jetzt sauber validieren:

Halten Sie Regeln als reine Funktionen, die eine Fehlermeldung oder null zurückgeben.
Zeigen Sie Fehler mit isError + supportingText an, und melden Sie Fehler nicht, bevor ein Feld berührt wurde.
Behandeln Sie feldübergreifende Regeln dort, wo beide Werte sichtbar sind.
Deaktivieren Sie das Absenden, bis das gesamte Formular gültig ist, und prüfen Sie beim Absenden erneut.
Verhindern Sie ungültige Eingaben mit filter und zentralisieren Sie die Regeln in einem ViewModel.

Als Nächstes: Tastaturtypen, IME-Aktionen und Fokusverwaltung.

Häufig gestellte Fragen

Ist die Lektion „Eingaben validieren“ kostenlos?

Ja — der vollständige Text von „Eingaben validieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Android Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Android Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Eingaben validieren“?

Eingaben prüfen und hilfreiche Fehler anzeigen Du übst Android Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Android Academy zu starten?

Keine Vorkenntnisse erforderlich. Android Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Eingaben validieren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Android Academy-Lektion Code schreiben und ausführen?

Ja. Jede Android Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Android Academy