"Power Fx Input Validation: IsMatch & IsBlank"

The Power Apps Approach to Validation

In traditional web development, you might manually attach validation logic to form submission events. While you can do that in Power Apps, the more idiomatic and user-friendly approach is to leverage the built-in properties of form controls.

When you use a Form control in a Canvas App, each field is contained within a DataCard control. These data cards have properties we can customize to implement validation:

• Required: A boolean property that marks a field as mandatory.
• ValidationState: An enum (ValidationState.Error, ValidationState.None) that controls the visual state of the input, such as showing a red border.
• ErrorMessage.Text: The text displayed in the error label associated with the card.
• ErrorMessage.Visible: Controls the visibility of that error label.

By manipulating these properties with Power Fx formulas, we can provide immediate, in-context feedback to the user.

Controlling When Validation Appears

A common challenge is that validation rules can trigger as soon as the form loads, showing a screen full of errors before the user has even interacted with it. This is a poor user experience.

A professional pattern to solve this is to use a variable that tracks whether the user has attempted to submit the form.

1. On your "Submit" button's OnSelect property: Set a variable.
   Set(varFormSubmitted, true)
2. On your "Cancel" or "Reset" button: Reset the variable.
   Set(varFormSubmitted, false)
3. In your validation formulas: Check this variable before applying the rule.
   If(varFormSubmitted && IsBlank(Self.Value), ...)

This ensures that error messages only appear after the user has made their first submission attempt.

Basic Validation: Checking for Blanks and Length

The most common validation requirements are ensuring a field is not empty and that its content meets a certain length. The key Power Fx functions for this are IsBlank() and Len().

Let's see how to combine these functions with the varFormSubmitted pattern to create custom validation logic.

As you saw, the core pattern for a text input's ValidationState property looks like this:

// On the ValidationState property of the text input control
If(
    varFormSubmitted && IsBlank(Self.Text),
    ValidationState.Error,  // Rule 1: Field is required
    If(
        varFormSubmitted && Len(Self.Text) < 5,
        ValidationState.Error, // Rule 2: Minimum 5 characters
        ValidationState.None   // All rules passed
    )
)

If(
    varFormSubmitted && IsBlank(Self.Selected), 
    ValidationState.Error, 
    ValidationState.None
)

Advanced Validation with IsMatch

For more complex scenarios like validating email formats, phone numbers, or specific product codes, IsMatch is the essential function. It tests a text string against a pattern. Your experience with regular expressions in other languages will be directly applicable here.

You can define a pattern in IsMatch in three ways:

1. Ordinary Characters: A simple string literal like "abc".
2. Predefined Patterns: An enum of common patterns like Match.Email or Match.MultipleDigits.
3. Regular Expressions: A powerful string pattern like "\d{3}-\d{2}-\d{4}" for a US social security number.

To get a foundational understanding of this function, please review the official Microsoft documentation.

Now let's see these concepts applied in a practical tutorial.

The Coalesce pattern shown in the video is particularly powerful. By applying it to the Text property of the error message label, you can create a prioritized list of validation rules:

// On the Text property of the ErrorMessage label
Coalesce(
    // Rule 1: Check if it's blank (and form submitted)
    If(varFormSubmitted && IsBlank(DataCardValue1.Text), "Product Code is required.", Blank()),

    // Rule 2: Check if it matches the 'PROD-####' format
    If(!IsMatch(DataCardValue1.Text, "PROD-\d{4}"), "Code must be in 'PROD-1234' format.", Blank())
)

Finalizing the Validation Strategy

A complete validation strategy provides clear feedback and prevents the user from submitting invalid data. The final step is often to disable the submit button until all errors are resolved.

You can achieve this by checking the Visible property of your error message labels on the DisplayMode property of the submit button.

// On the DisplayMode property of the Submit Button
If(
    ErrorMessage1.Visible || ErrorMessage2.Visible || ErrorMessage3.Visible,
    DisplayMode.Disabled,
    DisplayMode.Edit
)

This ensures the user cannot even attempt to use the Patch or SubmitForm functions we learned about previously until the data is in a valid state.

Conclusion

In this lesson, you've learned how to implement robust, client-side input validation in your Canvas Apps. By moving beyond simple required fields, you can create a much more guided and error-resistant user experience.

Key Takeaways:

• Leverage the built-in DataCard properties (ValidationState, ErrorMessage.Text) for an idiomatic Power Apps validation experience.
• Use a variable like varFormSubmitted to control when validation messages appear, preventing errors on initial form load.
• Use IsBlank and Len for basic required field and length checks.
• Employ IsMatch with predefined patterns or custom regular expressions for complex format validation.
• Chain multiple validation rules elegantly using the Coalesce function on the error message's Text property.
• Disable the submit button based on the visibility of error messages to prevent the submission of invalid data.

Up Next:
Validation is about preventing errors before they happen. But what about unexpected errors that can occur during data operations, like a network failure or a data source issue? In our next lesson, we will tackle this by learning to "Implement error handling for data source operations and formulas using the IfError and Errors functions."