GlideForm.hideFieldMsg() — ServiceNow API

g_form.hideFieldMsg(fieldName, clearAll)→ void

intermediateTested on Xanadu

What It Does

The hideFieldMsg() method removes informational, warning, or error messages that have been displayed beneath form fields. These messages are typically added by showFieldMsg() calls in client scripts, UI policies, or through server-side validation that surfaces on the client. The method operates entirely within the browser's DOM and doesn't communicate with the server.

ServiceNow maintains a message queue for each form field, allowing multiple messages to stack beneath a single field. When clearAll is false (the default), the platform removes only the most recently added message from the queue. When clearAll is true, the entire message queue for that field is cleared, removing all visible messages at once.

The method returns void and provides no indication of success or failure. If you specify a field name that doesn't exist on the current form, the method fails silently without throwing an error or logging a warning. This behavior is consistent with other GlideForm methods that operate on form fields.

An important edge case occurs with reference fields and their dependent fields. If you hide messages on a reference field that has dependent fields (like location → company), the dependent field messages remain visible even if they're logically related to the parent field's validation state. You must explicitly call hideFieldMsg() for each dependent field that needs its messages cleared.

This method works in conjunction with showFieldMsg() and clearMessages() to provide complete control over field-level messaging. Unlike clearMessages() which removes all messages from all fields on the form, hideFieldMsg() provides surgical precision for individual field message management.

When to Use This

Use hideFieldMsg() when you need to clear field-specific validation messages or informational text in response to user actions. Common scenarios include clearing error messages after a user corrects invalid input, removing conditional help text when certain selections change, or hiding temporary status messages after an async operation completes. This method is essential for creating responsive, user-friendly forms that provide immediate feedback.

Don't use this method when you need to clear messages from multiple fields simultaneously—use clearMessages() instead. Also avoid using it to hide form-wide notification messages that appear at the top of the form; those require clearMessages() or direct DOM manipulation. A common misuse pattern is calling this method repeatedly in onChange events without checking if messages actually exist, which creates unnecessary DOM operations.

Timing matters significantly with this method. Calling hideFieldMsg() immediately after showFieldMsg() in the same script execution can create race conditions where messages flicker or don't appear at all. When building complex validation flows, structure your logic to avoid immediately hiding messages you just displayed.

Return Value

The method returns void (undefined) in all cases. There's no return value to indicate success, failure, or whether any messages were actually removed. This design choice aligns with other GlideForm methods that perform UI operations rather than data retrieval. The method completes synchronously, so any code following the call will execute after the message hiding is complete.

Since there's no return value to check, you cannot programmatically determine if the operation succeeded. If you need to verify that messages were cleared, you'll need to implement your own tracking mechanism or use DOM inspection methods to check the current state of field messages after the call completes.

Free Newsletter

Enjoying this? Get one deep-dive per week.

Join 1,000+ ServiceNow pros — scripts, GlideRecord patterns, Flow Designer techniques, and career moves. Free.

Platform Behavior & Side Effects

Operates entirely on the client-side DOM without triggering any server communication or database operations
Does not fire Business Rules, ACLs, notifications, or any other server-side platform mechanisms
Executes synchronously with minimal performance impact—simply removes DOM elements from the message queue
Cannot be used in Before or After Business Rules since it requires the client-side form context
Works identically in UI Policies and Client Scripts, but UI Policy execution timing may affect message visibility
Messages cleared by this method are permanently removed from the client session—they won't reappear unless explicitly re-added
Form submission will proceed normally even if validation messages were hidden—clearing display messages doesn't affect underlying validation logic

Parameters

Name	Type	Required	Description
fieldName	string	Yes	The name of the field from which to hide messages. Must match the actual field name on the form, not the field label. Case-sensitive and will fail silently if the field doesn't exist on the current form.
clearAll	boolean	No	When true, removes all messages for the specified field. When false or omitted, removes only the most recently added message. Optional parameter that defaults to false if not provided.

Chrome Extension

Sourdough: ServiceNow Monitoring and Analytics

A Chrome extension for ServiceNow Admins and Developers with essential tools, analytics, graphs and monitoring features.

Instance HealthGraphs & ChartsAPI HealthDeveloper ToolsQuick SearchInstance Switcher

Add to Chrome

Free to install. Pro $5/month after a 14-day no-card trial.
Pro requires the ServiceNow admin role. Upgrade inside the extension.

Overview

Tasks

CMDB

API

Metrics

Monitor

Internals

Instance:sourdoughdev·Version:Yokohama

Instance StateONLINE

System StatusFully Operational

Session Timeout90 minutes

Logged-In Sessions2 (20 active)

Build Nameyokohama-12-18-2024_p1

IP Address10.159.128.43

Instance HealthHealth Score: 90%

🔥 5dSourdough (Chrome Plugin)Dark Mode

Code Examples

Basic usage — hiding the most recent messagebasic

function onChange(control, oldValue, newValue, isLoading, isTemplate) {
    if (isLoading || newValue == '') {
        return;
    }
    
    // Clear any previous validation message when user enters new data
    g_form.hideFieldMsg('caller_id');
    
    // Validate the new caller selection
    var caller = g_form.getReference('caller_id', function(ref) {
        if (!ref.active) {
            g_form.showFieldMsg('caller_id', 'Selected user is inactive', 'error');
        }
    });
}

This onChange script clears any existing caller_id messages when the user makes a new selection, then performs validation. Only the most recent message is removed, preserving any other messages that might exist for that field.

Intermediate — clearing all messages for comprehensive cleanupintermediate

function validateIncidentData() {
    var isValid = true;
    
    // Clear all previous validation messages for these fields
    g_form.hideFieldMsg('priority', true);
    g_form.hideFieldMsg('assignment_group', true);
    g_form.hideFieldMsg('assigned_to', true);
    
    // Comprehensive validation with fresh message state
    if (g_form.getValue('priority') == '1' && g_form.getValue('assignment_group') == '') {
        g_form.showFieldMsg('assignment_group', 'P1 incidents require assignment group', 'error');
        g_form.showFieldMsg('assignment_group', 'Contact Service Desk for immediate assignment', 'info');
        isValid = false;
    }
    
    return isValid;
}

Using clearAll parameter ensures a clean slate before running validation logic. This prevents message accumulation when validation runs multiple times, especially useful in complex forms with interdependent validation rules.

Advanced — avoiding the message flicker anti-patternadvanced

// WRONG - creates message flicker
function badOnChange(control, oldValue, newValue, isLoading) {
    g_form.showFieldMsg('state', 'Validating state change...', 'info');
    g_form.hideFieldMsg('state'); // Immediately hides the message we just showed
}

// CORRECT - proper async message management
function goodOnChange(control, oldValue, newValue, isLoading) {
    if (isLoading) return;
    
    // Clear old messages first
    g_form.hideFieldMsg('state', true);
    
    // Show loading message
    g_form.showFieldMsg('state', 'Validating state change...', 'info');
    
    // Simulate async validation with proper cleanup
    setTimeout(function() {
        g_form.hideFieldMsg('state');
        if (isValidStateTransition(oldValue, newValue)) {
            g_form.showFieldMsg('state', 'State change approved', 'info');
        }
    }, 1000);
}

The wrong pattern shows messages that immediately disappear. The correct approach clears old messages first, shows status during processing, then provides final feedback. This creates a smooth user experience without flickering messages.

Gotchas

The method fails silently if you specify a field name that doesn't exist on the current form—no error or warning is generated.

Calling hideFieldMsg() immediately after showFieldMsg() in the same script execution can cause message flickering or prevent messages from appearing entirely.

Messages hidden with this method don't reappear automatically—you must explicitly call showFieldMsg() again to redisplay field messages.

The clearAll parameter only affects the specified field—it doesn't impact messages on other fields, unlike the global clearMessages() method.

Reference field dependent fields retain their messages even when the parent reference field messages are cleared—each field must be handled separately.

Test Your Knowledge

Quick 3-question quiz — see how your ServiceNow skills stack up.

Question 1 of 3Performance

A list view on a table with millions of records is slow. Best fix?

Select an answer to continue