R: Validate input values and other conditions

validate {shiny} | R Documentation

## Validate input values and other conditions

### Description

For an output rendering function (e.g. `renderPlot()`), you may need to check that certain input values are available and valid before you can render the output. `validate` gives you a convenient mechanism for doing so.

### Usage

    validate(..., errorClass = character(0))

    need(expr, message = paste(label, "must be provided"), label)

### Arguments

`...` | A list of tests. Each test should equal `NULL` for success, `FALSE` for silent failure, or a string for failure with an error message.
`errorClass` | A CSS class to apply. The actual CSS string will have `shiny-output-error-` prepended to this value.
`expr` | An expression to test. The condition will pass if the expression meets the conditions spelled out in Details.
`message` | A message to convey to the user if the validation condition is not met. If no message is provided, one will be created using `label`. To fail with no message, use `FALSE` for the message.
`label` | A human-readable name for the field that may be missing. This parameter is not needed if `message` is provided, but must be provided otherwise.

### Details

The `validate` function takes any number of (unnamed) arguments, each of which represents a condition to test. If any of the conditions represent failure, then a special type of error is signaled which stops execution. If this error is not handled by application-specific code, it is displayed to the user by Shiny.

An easy way to provide arguments to `validate` is to use the `need` function, which takes an expression and a string; if the expression is considered a failure, then the string will be used as the error message. The `need` function considers its expression to be a failure if it is any of the following:

- `FALSE`

- `NULL`

- `""`

- An empty atomic vector

- An atomic vector that contains only missing values

- A logical vector that contains all `FALSE` or missing values

- An object of class `"try-error"`

- A value that represents an unclicked `actionButton`

If any of these values happen to be valid, you can explicitly turn them to logical values. For example, if you allow `NA` but not `NULL`, you can use the condition `!is.null(input$foo)`, because `!is.null(NA) == TRUE`.

If you need validation logic that differs significantly from `need`, you can create other validation test functions. A passing test should return `NULL`. A failing test should return an error message as a single-element character vector, or if the failure should happen silently, `FALSE`.

Because validation failure is signaled as an error, you can use `validate` in reactive expressions, and validation failures will automatically propagate to outputs that use the reactive expression. In other words, if reactive expression `a` needs `input$x`, and two outputs use `a` (and thus depend indirectly on `input$x`), it's not necessary for the outputs to validate `input$x` explicitly, as long as `a` does validate it.

### Examples

    ## Only run examples in interactive R sessions
    if (interactive()) {
    options(device.ask.default = FALSE)

    ui <- fluidPage(
      checkboxGroupInput('in1', 'Check some letters', choices = head(LETTERS)),
      selectizeInput('in2', 'Select a state', choices = state.name),
      plotOutput('plot')
    )

    server <- function(input, output) {
      output$plot <- renderPlot({
        validate(
          need(input$in1, 'Check at least one letter!'),
          need(input$in2 != '', 'Please choose a state.')
        )
        plot(1:10, main = paste(c(input$in1, input$in2), collapse = ', '))
      })
    }

    shinyApp(ui, server)

    }

[Package shiny version 1.0.3 Index]