Test for Empty Values in Javascript

Share this article

Testing for empty values in JavaScript is a crucial aspect of programming, as it helps in validating data and maintaining the application’s integrity. JavaScript provides various data types, such as strings, numbers, booleans, objects, and arrays, and each type has its own set of characteristics when it comes to checking for empty values. In this article, we’ll discuss a precise and efficient function called empty() to check for empty values in JavaScript. We’ll cover its implementation, use cases, and compare it to other methods that developers can use to check for empty values, along with examples and common pitfalls.

Before diving into the empty() function, let’s look at some examples of JavaScript data types and how to check if they are empty:

  1. Strings: A string can be considered empty if it has a length of zero or contains only whitespace characters. You can check for an empty string using the length property or a regular expression:
const emptyString = '';
console.log(emptyString.length === 0); // true

const whitespaceString = '  ';
console.log(/^\s*$/.test(whitespaceString)); // true
  1. Numbers: Numbers are never considered empty, but you might want to check if they are zero, NaN (Not-a-Number), or Infinity:
const num = 0;
console.log(num === 0); // true

const notANumber = NaN;
console.log(isNaN(notANumber)); // true

const infinite = Infinity;
console.log(infinite === Infinity); // true
  1. Booleans: Booleans can be either true or false, and they are never considered empty. However, you can check their values directly:
const bool = false;
console.log(bool === false); // true
  1. Arrays: An array is empty if it has no elements. You can use the length property to check for empty arrays:
const emptyArray = [];
console.log(emptyArray.length === 0); // true
  1. Objects: An object is empty if it has no enumerable properties. You can use a for...in loop or Object.keys() to check for empty objects:
const emptyObject = {};
console.log(Object.keys(emptyObject).length === 0); // true

Common Developer Errors

  • Using loose equality (==) can cause unexpected results when checking for empty values. For example, 0 == false returns true. Always use strict equality (===) for accurate comparisons.
  • When checking for empty values in arrays or objects, make sure to account for cases where the variable might be null or undefined before using the length property or Object.keys() method.
  • Be cautious about using the typeof operator when checking for empty values, as it returns the data type as a string, which can lead to confusion or errors if not used correctly.

The empty() Function: A Better Alternative

This custom empty() function combines the above situations and pitfalls to return check whether a variable is empty regardless of its data type.

Similar to PHP’s empty() function, our JavaScript function takes a variable or property and tells you if the value is empty by returning true or false. However, our JavaScript function is far more precise about what kinds of data can be considered empty:

  • undefined or null
  • a zero-length string
  • an array with no members
  • an object with no enumerable properties
  • Booleans and numbers are never empty, irrespective of their value.

Here’s our empty() function’s code:

const empty = (data) => {
  // Check if data is a number or boolean, and return false as they're never considered empty
  if (typeof data === 'number' || typeof data === 'boolean') {
    return false;
  // Check if data is undefined or null, and return true as they're considered empty
  if (typeof data === 'undefined' || data === null) {
    return true;

  // Check if data has a length property (e.g. strings, arrays) and return true if the length is 0
  if (typeof data.length !== 'undefined') {
    return data.length === 0;

  // Check if data is an object and use Object.keys() to determine if it has any enumerable properties
  if (typeof data === 'object') {
    return Object.keys(data).length === 0;

  // Return false for any other data types, as they're not considered empty
  return false;

Understanding the empty() Function

The function uses four conditions to test different data types:

  1. Booleans and numbers: This condition always returns false. Providing this flexibility allows passing in arbitrary data.
  2. Undefined and null: Helpful for setting defaults for optional function arguments. Although null is obviously not the same as undefined, for many intents and purposes they amount to the same thing (i.e. this piece of data does not have a wanted value). For example, if you query a web storage object using object syntax, a value that isn’t defined will be undefined, yet the getItem() method will return null.
  3. Length property: Detects empty strings and arrays with no members. You can extend this condition to check for strings with only whitespace, but that depends on your specific use case.
  4. Objects: If the Object has no keys (enumerable properties), the object is deemed empty.

Alternatives to Check for Empty Values

Developers can also use built-in methods or libraries to check for empty values in JavaScript. Some popular alternatives include:

Frequently Asked Questions (FAQs) about Empty Functions in JavaScript

What is an empty function in JavaScript?

An empty function in JavaScript is a function that has been declared but does not perform any action or return any value. It is defined with the function keyword, followed by a set of parentheses and a pair of curly braces with no code inside. For example, function() {} is an empty function. While it may seem pointless, empty functions can serve as placeholders in your code where functionality can be added later.

How do I create an empty function in JavaScript?

Creating an empty function in JavaScript is straightforward. You simply declare a function without adding any code inside the function body. Here’s an example:
function emptyFunction() {}
In this example, emptyFunction is an empty function because it doesn’t contain any statements or return any value.

When should I use an empty function in JavaScript?

Empty functions are often used as placeholders in your code. If you’re writing a program and you know that you’ll need a function in a certain place, but you’re not sure what it should do yet, you can use an empty function. This allows you to structure your code and continue developing without having to decide on the function’s behavior immediately.

Can an empty function return a value?

By default, an empty function in JavaScript does not return a value. However, you can modify an empty function to return a value if needed. For example:
function emptyFunction() {
return 'This is not empty anymore!';
In this case, the function will return the string ‘This is not empty anymore!’.

What happens when an empty function is called?

When an empty function is called, nothing happens. The function is executed, but since there is no code inside the function body, no action is taken. The function call completes immediately and control is returned to the calling code.

Can an empty function take parameters?

Yes, an empty function can take parameters. However, since the function doesn’t contain any code, it won’t do anything with the parameters. Here’s an example:
function emptyFunction(param1, param2) {}
In this case, emptyFunction takes two parameters, but it doesn’t use them for anything.

How can I test for empty values in JavaScript?

You can test for empty values in JavaScript using the == or === operators. For example, if you want to check if a variable x is empty, you can do:
if (x == null) {
// x is null or undefined
This will return true if x is either null or undefined.

What is the difference between null and undefined in JavaScript?

In JavaScript, null is an assignment value that represents no value or no object. It is an intentional absence of any object value. On the other hand, undefined means a variable has been declared but has not yet been assigned a value.

Can I use an empty function as a callback?

Yes, you can use an empty function as a callback. This is often done when you need to provide a function as a parameter, but you don’t want it to do anything. For example, you might use an empty function as a callback for an asynchronous operation that you don’t care about the result of.

Are empty functions in JavaScript considered bad practice?

Not necessarily. While it’s true that an empty function doesn’t do anything, it can still be useful as a placeholder or as a default parameter. However, you should avoid using empty functions when it’s not clear why the function is empty. If you’re using an empty function as a placeholder, it’s a good idea to add a comment explaining why.

Mark O'NeillMark O'Neill
View Author

Mark is the General Manager of SitePoint.com. He loves to read and write about technology, startups, programming languages, and no code tools.

Share this article
Read Next
Get the freshest news and resources for developers, designers and digital creators in your inbox each week