TypeScript: How to Check if a String is Empty

Updated: January 8, 2024 By: Guest Contributor Post a comment


TypeScript adds type safety to JavaScript, offering ways to understand and validate your data. Checking if a string is empty is a common operation – and TypeScript provides multiple approaches to this simple yet essential task.

Using Basic Comparison Operators

Let’s start by using the simplest method to check if a string is empty – comparing it with an empty string literal:

let myString: string = '';
console.log(myString === ''); // Output: true

Using the strict equality operator (===), you can directly compare the variable with a pair of quotes denoting an empty string.

Checking String Length

Another common approach involves checking the length property of the string:

let myString: string = '';
console.log(myString.length === 0); // Output: true

An empty string has a length of 0, providing a straightforward check for emptiness.

Using Boolean Context

In JavaScript and TypeScript, an empty string is falsy. This means you can use a simple if statement to check for an empty string:

let myString: string = '';
if (!myString) {
  console.log('The string is empty');

This method relies on the truthy/falsy nature of strings in TypeScript.

Creating a Utility Function

For code reusability, it’s wise to encapsulate the empty string check within a function:

function isEmpty(value: string): boolean {
  return value === '';

let myString: string = '';
console.log(isEmpty(myString)); // Output: true

Applying Type Guards

TypeScript’s type guards can be used to enhance the check, especially when dealing with a value that could potentially be null or undefined:

function isEmpty(value: string | null | undefined): boolean {
  return value === null || value === undefined || value === '';

let myString: string | null = null;
console.log(isEmpty(myString)); // Output: true

By broadening the type signature, we can safely check for emptiness in a variety of situations.

Working with Trim

If you want to consider strings with white space as empty, applying trim() before checking can be a good approach:

let myString: string = ' ';
console.log(myString.trim().length === 0); // Output: true

trim() removes whitespace from both ends of a string, which when followed by checking the length, effectively considers strings containing only whitespace as empty.

Using Regular Expressions

A more advanced approach for checking whitespace can involve regular expressions:

let myString: string = ' \t\n ';
console.log(/^\s*$/g.test(myString)); // Output: true

This regex tests for strings consisting only of whitespace. It looks for the start (^) followed by any whitespace character (\s), zero or more times (*), and then the end ($).

Dealing with Optional Chaining

Optional chaining (?.) is a more recent addition to TypeScript, allowing checks on possibly undefined or null properties:

let myString: string | null = null;
console.log(myString?.length === 0 || myString === null || myString === undefined); // Output: true

With optional chaining, if myString is null or undefined, the expression short-circuits and returns undefined, which leads us to compare undefined with 0, returning false. Therefore, we still need the checks for null and undefined.

Utilizing TypeScript’s Non-null Assertion Operator

When you are certain that a value is not null or undefined, TypeScript’s non-null assertion operator (!) can be employed:

let myString: string | undefined = '';
console.log(myString!.length === 0); // Output: true

Be cautious with this operator as it can suppress legitimate null/undefined errors and should only be used when the absence of null or undefined can be guaranteed.


TypeScript provides several methods for checking if a string is empty, each suitable for different scenarios. Whether you’re looking for a quick check, handling potential null or undefined values, or considering strings with whitespace as empty, TypeScript’s features offer a robust set of tools to work with these variations. Embed these practices in your coding routine to handle string checks efficiently and reliably.