get_settings_errors - Documentation

WordPress Version: 6.2

/**
 * Fetches settings errors registered by add_settings_error().
 *
 * Checks the $wp_settings_errors array for any errors declared during the current
 * pageload and returns them.
 *
 * If changes were just submitted ($_GET['settings-updated']) and settings errors were saved
 * to the 'settings_errors' transient then those errors will be returned instead. This
 * is used to pass errors back across pageloads.
 *
 * Use the $sanitize argument to manually re-sanitize the option before returning errors.
 * This is useful if you have errors or notices you want to show even when the user
 * hasn't submitted data (i.e. when they first load an options page, or in the {@see 'admin_notices'}
 * action hook).
 *
 * @since 3.0.0
 *
 * @global array[] $wp_settings_errors Storage array of errors registered during this pageload
 *
 * @param string $setting  Optional. Slug title of a specific setting whose errors you want.
 * @param bool   $sanitize Optional. Whether to re-sanitize the setting value before returning errors.
 * @return array[] {
 *     Array of settings error arrays.
 *
 *     @type array ...$0 {
 *         Associative array of setting error data.
 *
 *         @type string $setting Slug title of the setting to which this error applies.
 *         @type string $code    Slug-name to identify the error. Used as part of 'id' attribute in HTML output.
 *         @type string $message The formatted message text to display to the user (will be shown inside styled
 *                               `<div>` and `<p>` tags).
 *         @type string $type    Optional. Message type, controls HTML class. Possible values include 'error',
 *                               'success', 'warning', 'info'. Default 'error'.
 *     }
 * }
 */
function get_settings_errors($setting = '', $sanitize = false)
{
    global $wp_settings_errors;
    /*
     * If $sanitize is true, manually re-run the sanitization for this option
     * This allows the $sanitize_callback from register_setting() to run, adding
     * any settings errors you want to show by default.
     */
    if ($sanitize) {
        sanitize_option($setting, get_option($setting));
    }
    // If settings were passed back from options.php then use them.
    if (isset($_GET['settings-updated']) && $_GET['settings-updated'] && get_transient('settings_errors')) {
        $wp_settings_errors = array_merge((array) $wp_settings_errors, get_transient('settings_errors'));
        delete_transient('settings_errors');
    }
    // Check global in case errors have been added on this pageload.
    if (empty($wp_settings_errors)) {
        return array();
    }
    // Filter the results to those of a specific setting if one was set.
    if ($setting) {
        $setting_errors = array();
        foreach ((array) $wp_settings_errors as $key => $details) {
            if ($setting === $details['setting']) {
                $setting_errors[] = $wp_settings_errors[$key];
            }
        }
        return $setting_errors;
    }
    return $wp_settings_errors;
}

WordPress Version: 6.1

/**
 * Fetches settings errors registered by add_settings_error().
 *
 * Checks the $wp_settings_errors array for any errors declared during the current
 * pageload and returns them.
 *
 * If changes were just submitted ($_GET['settings-updated']) and settings errors were saved
 * to the 'settings_errors' transient then those errors will be returned instead. This
 * is used to pass errors back across pageloads.
 *
 * Use the $sanitize argument to manually re-sanitize the option before returning errors.
 * This is useful if you have errors or notices you want to show even when the user
 * hasn't submitted data (i.e. when they first load an options page, or in the {@see 'admin_notices'}
 * action hook).
 *
 * @since 3.0.0
 *
 * @global array[] $wp_settings_errors Storage array of errors registered during this pageload
 *
 * @param string $setting  Optional. Slug title of a specific setting whose errors you want.
 * @param bool   $sanitize Optional. Whether to re-sanitize the setting value before returning errors.
 * @return array {
 *     Array of settings errors.
 *
 *     @type string $setting Slug title of the setting to which this error applies.
 *     @type string $code    Slug-name to identify the error. Used as part of 'id' attribute in HTML output.
 *     @type string $message The formatted message text to display to the user (will be shown inside styled
 *                           `<div>` and `<p>` tags).
 *     @type string $type    Optional. Message type, controls HTML class. Possible values include 'error',
 *                           'success', 'warning', 'info'. Default 'error'.
 * }
 */
function get_settings_errors($setting = '', $sanitize = false)
{
    global $wp_settings_errors;
    /*
     * If $sanitize is true, manually re-run the sanitization for this option
     * This allows the $sanitize_callback from register_setting() to run, adding
     * any settings errors you want to show by default.
     */
    if ($sanitize) {
        sanitize_option($setting, get_option($setting));
    }
    // If settings were passed back from options.php then use them.
    if (isset($_GET['settings-updated']) && $_GET['settings-updated'] && get_transient('settings_errors')) {
        $wp_settings_errors = array_merge((array) $wp_settings_errors, get_transient('settings_errors'));
        delete_transient('settings_errors');
    }
    // Check global in case errors have been added on this pageload.
    if (empty($wp_settings_errors)) {
        return array();
    }
    // Filter the results to those of a specific setting if one was set.
    if ($setting) {
        $setting_errors = array();
        foreach ((array) $wp_settings_errors as $key => $details) {
            if ($setting === $details['setting']) {
                $setting_errors[] = $wp_settings_errors[$key];
            }
        }
        return $setting_errors;
    }
    return $wp_settings_errors;
}

WordPress Version: 5.6

/**
 * Fetch settings errors registered by add_settings_error().
 *
 * Checks the $wp_settings_errors array for any errors declared during the current
 * pageload and returns them.
 *
 * If changes were just submitted ($_GET['settings-updated']) and settings errors were saved
 * to the 'settings_errors' transient then those errors will be returned instead. This
 * is used to pass errors back across pageloads.
 *
 * Use the $sanitize argument to manually re-sanitize the option before returning errors.
 * This is useful if you have errors or notices you want to show even when the user
 * hasn't submitted data (i.e. when they first load an options page, or in the {@see 'admin_notices'}
 * action hook).
 *
 * @since 3.0.0
 *
 * @global array $wp_settings_errors Storage array of errors registered during this pageload
 *
 * @param string $setting  Optional. Slug title of a specific setting whose errors you want.
 * @param bool   $sanitize Optional. Whether to re-sanitize the setting value before returning errors.
 * @return array {
 *     Array of settings errors.
 *
 *     @type string $setting Slug title of the setting to which this error applies.
 *     @type string $code    Slug-name to identify the error. Used as part of 'id' attribute in HTML output.
 *     @type string $message The formatted message text to display to the user (will be shown inside styled
 *                           `<div>` and `<p>` tags).
 *     @type string $type    Optional. Message type, controls HTML class. Possible values include 'error',
 *                           'success', 'warning', 'info'. Default 'error'.
 * }
 */
function get_settings_errors($setting = '', $sanitize = false)
{
    global $wp_settings_errors;
    /*
     * If $sanitize is true, manually re-run the sanitization for this option
     * This allows the $sanitize_callback from register_setting() to run, adding
     * any settings errors you want to show by default.
     */
    if ($sanitize) {
        sanitize_option($setting, get_option($setting));
    }
    // If settings were passed back from options.php then use them.
    if (isset($_GET['settings-updated']) && $_GET['settings-updated'] && get_transient('settings_errors')) {
        $wp_settings_errors = array_merge((array) $wp_settings_errors, get_transient('settings_errors'));
        delete_transient('settings_errors');
    }
    // Check global in case errors have been added on this pageload.
    if (empty($wp_settings_errors)) {
        return array();
    }
    // Filter the results to those of a specific setting if one was set.
    if ($setting) {
        $setting_errors = array();
        foreach ((array) $wp_settings_errors as $key => $details) {
            if ($setting === $details['setting']) {
                $setting_errors[] = $wp_settings_errors[$key];
            }
        }
        return $setting_errors;
    }
    return $wp_settings_errors;
}

WordPress Version: 5.5

/**
 * Fetch settings errors registered by add_settings_error().
 *
 * Checks the $wp_settings_errors array for any errors declared during the current
 * pageload and returns them.
 *
 * If changes were just submitted ($_GET['settings-updated']) and settings errors were saved
 * to the 'settings_errors' transient then those errors will be returned instead. This
 * is used to pass errors back across pageloads.
 *
 * Use the $sanitize argument to manually re-sanitize the option before returning errors.
 * This is useful if you have errors or notices you want to show even when the user
 * hasn't submitted data (i.e. when they first load an options page, or in the {@see 'admin_notices'}
 * action hook).
 *
 * @since 3.0.0
 *
 * @global array $wp_settings_errors Storage array of errors registered during this pageload
 *
 * @param string $setting  Optional. Slug title of a specific setting whose errors you want.
 * @param bool   $sanitize Optional. Whether to re-sanitize the setting value before returning errors.
 * @return array Array of settings errors.
 */
function get_settings_errors($setting = '', $sanitize = false)
{
    global $wp_settings_errors;
    /*
     * If $sanitize is true, manually re-run the sanitization for this option
     * This allows the $sanitize_callback from register_setting() to run, adding
     * any settings errors you want to show by default.
     */
    if ($sanitize) {
        sanitize_option($setting, get_option($setting));
    }
    // If settings were passed back from options.php then use them.
    if (isset($_GET['settings-updated']) && $_GET['settings-updated'] && get_transient('settings_errors')) {
        $wp_settings_errors = array_merge((array) $wp_settings_errors, get_transient('settings_errors'));
        delete_transient('settings_errors');
    }
    // Check global in case errors have been added on this pageload.
    if (empty($wp_settings_errors)) {
        return array();
    }
    // Filter the results to those of a specific setting if one was set.
    if ($setting) {
        $setting_errors = array();
        foreach ((array) $wp_settings_errors as $key => $details) {
            if ($setting === $details['setting']) {
                $setting_errors[] = $wp_settings_errors[$key];
            }
        }
        return $setting_errors;
    }
    return $wp_settings_errors;
}

WordPress Version: 5.1

/**
 * Fetch settings errors registered by add_settings_error().
 *
 * Checks the $wp_settings_errors array for any errors declared during the current
 * pageload and returns them.
 *
 * If changes were just submitted ($_GET['settings-updated']) and settings errors were saved
 * to the 'settings_errors' transient then those errors will be returned instead. This
 * is used to pass errors back across pageloads.
 *
 * Use the $sanitize argument to manually re-sanitize the option before returning errors.
 * This is useful if you have errors or notices you want to show even when the user
 * hasn't submitted data (i.e. when they first load an options page, or in the {@see 'admin_notices'}
 * action hook).
 *
 * @since 3.0.0
 *
 * @global array $wp_settings_errors Storage array of errors registered during this pageload
 *
 * @param string $setting Optional slug title of a specific setting whose errors you want.
 * @param boolean $sanitize Whether to re-sanitize the setting value before returning errors.
 * @return array Array of settings errors.
 */
function get_settings_errors($setting = '', $sanitize = false)
{
    global $wp_settings_errors;
    /*
     * If $sanitize is true, manually re-run the sanitization for this option
     * This allows the $sanitize_callback from register_setting() to run, adding
     * any settings errors you want to show by default.
     */
    if ($sanitize) {
        sanitize_option($setting, get_option($setting));
    }
    // If settings were passed back from options.php then use them.
    if (isset($_GET['settings-updated']) && $_GET['settings-updated'] && get_transient('settings_errors')) {
        $wp_settings_errors = array_merge((array) $wp_settings_errors, get_transient('settings_errors'));
        delete_transient('settings_errors');
    }
    // Check global in case errors have been added on this pageload.
    if (empty($wp_settings_errors)) {
        return array();
    }
    // Filter the results to those of a specific setting if one was set.
    if ($setting) {
        $setting_errors = array();
        foreach ((array) $wp_settings_errors as $key => $details) {
            if ($setting == $details['setting']) {
                $setting_errors[] = $wp_settings_errors[$key];
            }
        }
        return $setting_errors;
    }
    return $wp_settings_errors;
}

WordPress Version: 4.9

/**
 * Fetch settings errors registered by add_settings_error()
 *
 * Checks the $wp_settings_errors array for any errors declared during the current
 * pageload and returns them.
 *
 * If changes were just submitted ($_GET['settings-updated']) and settings errors were saved
 * to the 'settings_errors' transient then those errors will be returned instead. This
 * is used to pass errors back across pageloads.
 *
 * Use the $sanitize argument to manually re-sanitize the option before returning errors.
 * This is useful if you have errors or notices you want to show even when the user
 * hasn't submitted data (i.e. when they first load an options page, or in the {@see 'admin_notices'}
 * action hook).
 *
 * @since 3.0.0
 *
 * @global array $wp_settings_errors Storage array of errors registered during this pageload
 *
 * @param string $setting Optional slug title of a specific setting who's errors you want.
 * @param boolean $sanitize Whether to re-sanitize the setting value before returning errors.
 * @return array Array of settings errors
 */
function get_settings_errors($setting = '', $sanitize = false)
{
    global $wp_settings_errors;
    /*
     * If $sanitize is true, manually re-run the sanitization for this option
     * This allows the $sanitize_callback from register_setting() to run, adding
     * any settings errors you want to show by default.
     */
    if ($sanitize) {
        sanitize_option($setting, get_option($setting));
    }
    // If settings were passed back from options.php then use them.
    if (isset($_GET['settings-updated']) && $_GET['settings-updated'] && get_transient('settings_errors')) {
        $wp_settings_errors = array_merge((array) $wp_settings_errors, get_transient('settings_errors'));
        delete_transient('settings_errors');
    }
    // Check global in case errors have been added on this pageload.
    if (empty($wp_settings_errors)) {
        return array();
    }
    // Filter the results to those of a specific setting if one was set.
    if ($setting) {
        $setting_errors = array();
        foreach ((array) $wp_settings_errors as $key => $details) {
            if ($setting == $details['setting']) {
                $setting_errors[] = $wp_settings_errors[$key];
            }
        }
        return $setting_errors;
    }
    return $wp_settings_errors;
}

WordPress Version: 4.6

/**
 * Fetch settings errors registered by add_settings_error()
 *
 * Checks the $wp_settings_errors array for any errors declared during the current
 * pageload and returns them.
 *
 * If changes were just submitted ($_GET['settings-updated']) and settings errors were saved
 * to the 'settings_errors' transient then those errors will be returned instead. This
 * is used to pass errors back across pageloads.
 *
 * Use the $sanitize argument to manually re-sanitize the option before returning errors.
 * This is useful if you have errors or notices you want to show even when the user
 * hasn't submitted data (i.e. when they first load an options page, or in the {@see 'admin_notices'}
 * action hook).
 *
 * @since 3.0.0
 *
 * @global array $wp_settings_errors Storage array of errors registered during this pageload
 *
 * @param string $setting Optional slug title of a specific setting who's errors you want.
 * @param boolean $sanitize Whether to re-sanitize the setting value before returning errors.
 * @return array Array of settings errors
 */
function get_settings_errors($setting = '', $sanitize = false)
{
    global $wp_settings_errors;
    /*
     * If $sanitize is true, manually re-run the sanitization for this option
     * This allows the $sanitize_callback from register_setting() to run, adding
     * any settings errors you want to show by default.
     */
    if ($sanitize) {
        sanitize_option($setting, get_option($setting));
    }
    // If settings were passed back from options.php then use them.
    if (isset($_GET['settings-updated']) && $_GET['settings-updated'] && get_transient('settings_errors')) {
        $wp_settings_errors = array_merge((array) $wp_settings_errors, get_transient('settings_errors'));
        delete_transient('settings_errors');
    }
    // Check global in case errors have been added on this pageload.
    if (!count($wp_settings_errors)) {
        return array();
    }
    // Filter the results to those of a specific setting if one was set.
    if ($setting) {
        $setting_errors = array();
        foreach ((array) $wp_settings_errors as $key => $details) {
            if ($setting == $details['setting']) {
                $setting_errors[] = $wp_settings_errors[$key];
            }
        }
        return $setting_errors;
    }
    return $wp_settings_errors;
}

WordPress Version: 4.0

/**
 * Fetch settings errors registered by add_settings_error()
 *
 * Checks the $wp_settings_errors array for any errors declared during the current
 * pageload and returns them.
 *
 * If changes were just submitted ($_GET['settings-updated']) and settings errors were saved
 * to the 'settings_errors' transient then those errors will be returned instead. This
 * is used to pass errors back across pageloads.
 *
 * Use the $sanitize argument to manually re-sanitize the option before returning errors.
 * This is useful if you have errors or notices you want to show even when the user
 * hasn't submitted data (i.e. when they first load an options page, or in admin_notices action hook)
 *
 * @since 3.0.0
 *
 * @global array $wp_settings_errors Storage array of errors registered during this pageload
 *
 * @param string $setting Optional slug title of a specific setting who's errors you want.
 * @param boolean $sanitize Whether to re-sanitize the setting value before returning errors.
 * @return array Array of settings errors
 */
function get_settings_errors($setting = '', $sanitize = false)
{
    global $wp_settings_errors;
    /*
     * If $sanitize is true, manually re-run the sanitization for this option
     * This allows the $sanitize_callback from register_setting() to run, adding
     * any settings errors you want to show by default.
     */
    if ($sanitize) {
        sanitize_option($setting, get_option($setting));
    }
    // If settings were passed back from options.php then use them.
    if (isset($_GET['settings-updated']) && $_GET['settings-updated'] && get_transient('settings_errors')) {
        $wp_settings_errors = array_merge((array) $wp_settings_errors, get_transient('settings_errors'));
        delete_transient('settings_errors');
    }
    // Check global in case errors have been added on this pageload.
    if (!count($wp_settings_errors)) {
        return array();
    }
    // Filter the results to those of a specific setting if one was set.
    if ($setting) {
        $setting_errors = array();
        foreach ((array) $wp_settings_errors as $key => $details) {
            if ($setting == $details['setting']) {
                $setting_errors[] = $wp_settings_errors[$key];
            }
        }
        return $setting_errors;
    }
    return $wp_settings_errors;
}

WordPress Version: 3.7

/**
 * Fetch settings errors registered by add_settings_error()
 *
 * Checks the $wp_settings_errors array for any errors declared during the current
 * pageload and returns them.
 *
 * If changes were just submitted ($_GET['settings-updated']) and settings errors were saved
 * to the 'settings_errors' transient then those errors will be returned instead. This
 * is used to pass errors back across pageloads.
 *
 * Use the $sanitize argument to manually re-sanitize the option before returning errors.
 * This is useful if you have errors or notices you want to show even when the user
 * hasn't submitted data (i.e. when they first load an options page, or in admin_notices action hook)
 *
 * @since 3.0.0
 *
 * @global array $wp_settings_errors Storage array of errors registered during this pageload
 *
 * @param string $setting Optional slug title of a specific setting who's errors you want.
 * @param boolean $sanitize Whether to re-sanitize the setting value before returning errors.
 * @return array Array of settings errors
 */
function get_settings_errors($setting = '', $sanitize = false)
{
    global $wp_settings_errors;
    // If $sanitize is true, manually re-run the sanitization for this option
    // This allows the $sanitize_callback from register_setting() to run, adding
    // any settings errors you want to show by default.
    if ($sanitize) {
        sanitize_option($setting, get_option($setting));
    }
    // If settings were passed back from options.php then use them
    if (isset($_GET['settings-updated']) && $_GET['settings-updated'] && get_transient('settings_errors')) {
        $wp_settings_errors = array_merge((array) $wp_settings_errors, get_transient('settings_errors'));
        delete_transient('settings_errors');
    }
    // Check global in case errors have been added on this pageload
    if (!count($wp_settings_errors)) {
        return array();
    }
    // Filter the results to those of a specific setting if one was set
    if ($setting) {
        $setting_errors = array();
        foreach ((array) $wp_settings_errors as $key => $details) {
            if ($setting == $details['setting']) {
                $setting_errors[] = $wp_settings_errors[$key];
            }
        }
        return $setting_errors;
    }
    return $wp_settings_errors;
}