Skip to main content

How to Check if a String is Empty in JavaScript

Validating input is a crucial part of programming, and a fundamental check is to determine if a string is empty. This is essential for validating form fields, parsing data, or preventing errors from processing blank values.

This guide will teach you the standard methods for checking if a string is empty. You will learn how to check for a strictly empty string, and how to handle the common real-world scenario of a string that contains only whitespace.

The Core Problem: Empty vs. Whitespace-Only Strings​

It's important to distinguish between two different definitions of "empty":

  • Strictly Empty: The string has a length of 0 (e.g., '').
  • Whitespace-Only: The string contains only whitespace characters (spaces, tabs, newlines), like ' '.

For user input, you almost always want to treat a whitespace-only string as empty.

How to Check for a Strictly Empty String ('')​

If you need to check if a string has exactly zero characters, the most direct way is to check its length property.

For example, you want to know if a string is literally empty.

// Problem: How to check if this string is truly empty?
const myString = '';

Solution:

function isStrictlyEmpty(str) {
  // We also check if the value is actually a string
  return typeof str === 'string' && str.length === 0;
}

// Example Usage:
console.log(isStrictlyEmpty(''));       // Output: true
console.log(isStrictlyEmpty('  '));     // Output: false
console.log(isStrictlyEmpty('hello'));  // Output: false
note

This is a precise check, but it doesn't account for whitespace.

This is the most common and practical use case. The best way to handle this is to first remove any leading or trailing whitespace with the String.prototype.trim() method and then check the length.

For example, a user submits a form field containing only spaces. Your validation should treat this as empty.

This is the recommended best practice for most validation scenarios.

function isEmptyOrWhitespace(str) {
  // Check if the value is a string and if, after trimming, it is empty.
  return typeof str !== 'string' || str.trim().length === 0;
}

// Example Usage:
console.log(isEmptyOrWhitespace(''));       // Output: true
console.log(isEmptyOrWhitespace('  '));     // Output: true
console.log(isEmptyOrWhitespace('hello'));  // Output: false
console.log(isEmptyOrWhitespace(null));     // Output: true

How it works:

  • str.trim(): This method removes all whitespace from both the beginning and end of the string.
  • If the string was ' ', str.trim() returns ''.
  • We then check the .length of the trimmed string. If it's 0, the string was either empty or contained only whitespace.

A Note on Checking for "Falsy" Values​

In JavaScript, an empty string ('') is a "falsy" value, meaning it evaluates to false in a boolean context. You can use this for a very quick, but less precise, check.

const myString = '';

if (!myString) {
  console.log('The string is falsy (could be empty, null, undefined, 0, etc.)');
}
note

The Pitfall: This check is not specific. The if block will also run if myString is null, undefined, 0, false, or NaN. This is useful for checking if a variable "has a value," but it's not a precise way to check if it's specifically an empty string. It also doesn't handle whitespace-only strings.

Conclusion​

For checking if a string is empty, choosing the right method depends on whether you need to account for whitespace.

  • To check for a strictly empty string (''), the most direct method is str.length === 0.
  • The recommended best practice for most real-world scenarios (like user input) is to check for an empty or whitespace-only string using str.trim().length === 0.

By using the .trim() method, you can create robust validation logic that correctly handles user input and prevents empty or whitespace-only values from being processed.

Table of Contents